diff --git a/ej2-react/Release-notes/31.2.2.md b/ej2-react/Release-notes/31.2.2.md
new file mode 100644
index 000000000..295aa9c87
--- /dev/null
+++ b/ej2-react/Release-notes/31.2.2.md
@@ -0,0 +1,97 @@
+---
+title: Essential Studio for React Release Notes
+description: Learn here about the controls in the Essential Studio for React 2025 Volume 2 SP Release - Release Notes
+platform: ej2-react
+documentation: ug
+---
+
+# Essential Studio for React - v31.2.2 Release Notes
+
+{% include release-info.html date="October 14, 2025" version="v31.2.2" passed="63079" failed="0" %}
+
+{% directory path: _includes/release-notes/v31.2.2 %}
+
+{% include {{file.url}} %}
+
+{% enddirectory %}
+
+## Test Results
+
+| Component Name | Test Cases | Passed | Failed | Remarks |
+|---------------|------------|--------|--------|---------|
+| 3D Chart | 232 | 232 | 0 | All Passed |
+| 3D Circular Chart | 374 | 374 | 0 | All Passed |
+| Accordion | 205 | 205 | 0 | All Passed |
+| AI Assist View | 431 | 431 | 0 | All Passed |
+| App Bar | 67 | 67 | 0 | All Passed |
+| AutoComplete | 200 | 200 | 0 | All Passed |
+| Breadcrumb | 160 | 160 | 0 | All Passed |
+| Bullet Chart | 168 | 168 | 0 | All Passed |
+| Button | 144 | 144 | 0 | All Passed |
+| ButtonGroup | 120 | 120 | 0 | All Passed |
+| calendar | 177 | 177 | 0 | All Passed |
+| Carousel | 61 | 61 | 0 | All Passed |
+| Chart | 4744 | 4744 | 0 | All Passed |
+| Chat UI | 184 | 184 | 0 | All Passed |
+| CircularGauge | 429 | 429 | 0 | All Passed |
+| ColorPicker | 130 | 130 | 0 | All Passed |
+| Combo Box | 139 | 139 | 0 | All Passed |
+| Common | 904 | 904 | 0 | All Passed |
+| Context Menu | 105 | 105 | 0 | All Passed |
+| Data Grid | 3662 | 3662 | 0 | All Passed |
+| Date Picker | 426 | 426 | 0 | All Passed |
+| Date Range Picker | 519 | 519 | 0 | All Passed |
+| Date Time Picker | 324 | 324 | 0 | All Passed |
+| Diagram | 12813 | 12813 | 0 | All Passed |
+| Dialog | 58 | 58 | 0 | All Passed |
+| DropDown Button | 132 | 132 | 0 | All Passed |
+| Dropdown List | 193 | 193 | 0 | All Passed |
+| Dropdown Tree | 105 | 105 | 0 | All Passed |
+| File Manager | 2187 | 2187 | 0 | All Passed |
+| Floating Action Button | 132 | 132 | 0 | All Passed |
+| Gantt | 3515 | 3515 | 0 | All Passed |
+| HeatMap Chart | 635 | 635 | 0 | All Passed |
+| Image Editor | 1653 | 1653 | 0 | All Passed |
+| In-place Editor | 642 | 642 | 0 | All Passed |
+| Kanban | 268 | 268 | 0 | All Passed |
+| LinearGauge | 426 | 426 | 0 | All Passed |
+| Listbox | 115 | 115 | 0 | All Passed |
+| ListView | 84 | 84 | 0 | All Passed |
+| Maps | 1368 | 1368 | 0 | All Passed |
+| Mention | 35 | 35 | 0 | All Passed |
+| Menu | 187 | 187 | 0 | All Passed |
+| Multicolumn Combo Box | 254 | 254 | 0 | All Passed |
+| Multiselect Dropdown | 417 | 417 | 0 | All Passed |
+| OTP Input | 240 | 240 | 0 | All Passed |
+| Pivot Table | 5303 | 5303 | 0 | All Passed |
+| Progress Bar | 81 | 81 | 0 | All Passed |
+| Progress Button | 132 | 132 | 0 | All Passed |
+| Query Builder | 480 | 480 | 0 | All Passed |
+| RadioButton | 36 | 36 | 0 | All Passed |
+| RangeNavigator | 140 | 140 | 0 | All Passed |
+| Rating | 198 | 198 | 0 | All Passed |
+| Ribbon | 623 | 623 | 0 | All Passed |
+| Rich Text Editor | 5095 | 5095 | 0 | All Passed |
+| schedule | 4608 | 4608 | 0 | All Passed |
+| sidebar | 88 | 88 | 0 | All Passed |
+| Signature | 105 | 105 | 0 | All Passed |
+| Skeleton | 144 | 144 | 0 | All Passed |
+| Slider | 147 | 147 | 0 | All Passed |
+| SmithChart | 49 | 49 | 0 | All Passed |
+| Sparkline | 58 | 58 | 0 | All Passed |
+| Speech To Text | 200 | 200 | 0 | All Passed |
+| Speed Dial | 122 | 122 | 0 | All Passed |
+| Split Button | 144 | 144 | 0 | All Passed |
+| Stepper | 91 | 91 | 0 | All Passed |
+| Stock Chart | 379 | 379 | 0 | All Passed |
+| Tab | 69 | 69 | 0 | All Passed |
+| Text Area | 107 | 107 | 0 | All Passed |
+| TextBox | 54 | 54 | 0 | All Passed |
+| Time Picker | 180 | 180 | 0 | All Passed |
+| Timeline | 213 | 213 | 0 | All Passed |
+| Toast | 139 | 139 | 0 | All Passed |
+| Toolbar | 112 | 112 | 0 | All Passed |
+| ToolTip | 136 | 136 | 0 | All Passed |
+| TreeGrid | 3786 | 3786 | 0 | All Passed |
+| Treemap | 326 | 326 | 0 | All Passed |
+| Treeview | 370 | 370 | 0 | All Passed |
\ No newline at end of file
diff --git a/ej2-react/ai-assistview/ai-integrations/gemini-integration.md b/ej2-react/ai-assistview/ai-integrations/gemini-integration.md
index c14740f76..2504fe1f6 100644
--- a/ej2-react/ai-assistview/ai-integrations/gemini-integration.md
+++ b/ej2-react/ai-assistview/ai-integrations/gemini-integration.md
@@ -45,7 +45,11 @@ npm install @google/generative-ai
## Generate API Key
+<<<<<<< HEAD
1. Go to [Google AI Studio](https://aistudio.google.com/app/apikey) and sign in with your Google account. If you don’t have one, create a new account.
+=======
+1. Go to [Google AI Studio](https://aistudio.google.com/app/apikey) and sign in with your google account. If you don’t have one, create a new account.
+>>>>>>> remotes/origin/development
2. Once logged in, click on `Get API Key` from the left-hand menu or the top-right corner of the dashboard.
@@ -88,4 +92,8 @@ npm start
```
+<<<<<<< HEAD
Open the hosted link to interact with the Gemini AI for dynamic response.
+=======
+Open the hosted link to interact with the Gemini AI for dynamic response
+>>>>>>> remotes/origin/development
diff --git a/ej2-react/ai-assistview/ai-integrations/ollama-llm-integration.md b/ej2-react/ai-assistview/ai-integrations/ollama-llm-integration.md
new file mode 100644
index 000000000..cb51f7cdf
--- /dev/null
+++ b/ej2-react/ai-assistview/ai-integrations/ollama-llm-integration.md
@@ -0,0 +1,113 @@
+---
+layout: post
+title: LLM Model With React AI AssistView component | Syncfusion
+description: Checkout and learn about Integration of LLM Model With React AI AssistView component of Syncfusion Essential JS 2 and more details.
+platform: ej2-react
+control: AI AssistView
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# LLM via Ollama With AI AssistView component
+
+The Syncfusion AI AssistView supports integration with [LLM via Ollama](https://ollama.com), enabling advanced conversational AI features in your applications. The component acts as a UI for a support bot, where user prompts are sent to the selected AI service via API calls.
+
+## Prerequisites
+
+* Requires `Node.js` (v16 or higher) and `npm`.
+* [Ollama](https://ollama.com) application should be installed to run and manage LLM models locally.
+* Syncfusion AI AssistView for React `@syncfusion/ej2-react-interactive-chat` installed in your react project.
+
+## Step 1: Getting Started with the AI AssistView component
+
+Before integrating LLM model, ensure that the Syncfusion AI AssistView component is correctly rendered in your application:
+
+[ React Getting Started Guide](../getting-started)
+
+## Step 2: Install Dependencies
+
+* Install the Syncfusion AI AssistView in your project
+
+```bash
+
+npm install @syncfusion/ej2-react-interactive-chat --save
+
+```
+
+* Download and install `Ollama` based on your operating system:
+
+{% tabs %}
+{% highlight ts tabtitle="Windows" %}
+
+1. Visit [Windows](https://ollama.com/download)
+2. Click `Download for Windows` to get the `.exe installer`.
+3. Run `OllamaSetup.exe` and follow the wizard to install.
+
+{% endhighlight %}
+
+{% highlight ts tabtitle="MAC" %}
+
+1. Visit [macOS](https://ollama.com/download/mac)
+2. Click `Download for macOS` to get `.dmg file`
+3. Install it by following the wizard.
+
+{% endhighlight %}
+
+{% highlight ts tabtitle="Linux" %}
+
+1. Visit [Linux](https://ollama.com/download/linux)
+2. Run the below command to install Ollama in your system
+
+```bash
+
+curl -fsSL https://ollama.com/install.sh | sh
+
+```
+
+{% endhighlight %}
+{% endtabs %}
+
+## Step 3: Install and Run an Ollama Model
+
+1. Download and run a model using the following command. Replace `deepseek-r1` with your preferred model (e.g., `llama3`, `phi4`). See the [Ollama model](https://ollama.com/search) library for available models
+
+```bash
+
+ollama run deepseek-r1
+
+```
+
+2. Once the model download is complete, start the Ollama server to make the model accessible:
+
+```bash
+
+ollama serve
+
+```
+
+## Step 4: Configure AI AssistView in React
+
+Create `src/App.js` to connect the Syncfusion AI AssistView to the LLM model:
+
+{% tabs %}
+{% highlight js tabtitle="index.jsx" %}
+{% include code-snippet/ai-assistview/ai-integrations/llm-model/app/index.jsx %}
+{% endhighlight %}
+{% highlight ts tabtitle="index.tsx" %}
+{% include code-snippet/ai-assistview/ai-integrations/llm-model/app/index.tsx %}
+{% endhighlight %}
+{% endtabs %}
+
+{% previewsample "page.domainurl/code-snippet/ai-assistview/ai-integrations/llm-model" %}
+
+## Step 5: Run and Test
+
+Run the application in the browser using the following command.
+
+```bash
+
+npm start
+
+```
+
+Open the hosted link to interact with your AI model where you can enter prompts and receive responses from the Ollama model.
diff --git a/ej2-react/ai-assistview/ai-integrations/openai-integration.md b/ej2-react/ai-assistview/ai-integrations/openai-integration.md
index d98a52a70..107d97e66 100644
--- a/ej2-react/ai-assistview/ai-integrations/openai-integration.md
+++ b/ej2-react/ai-assistview/ai-integrations/openai-integration.md
@@ -15,7 +15,11 @@ The Syncfusion AI AssistView supports integration with [Azure Open AI](https://m
## Getting Started with the AI AssistView component
+<<<<<<< HEAD
Before integrating Azure Open AI, ensure that the Syncfusion AI AssistView component is correctly rendered in your React app:
+=======
+Before integrating Azure Open AI, ensure that the Syncfusion AI AssistView Component is correctly rendered in your React app:
+>>>>>>> remotes/origin/development
[React Getting Started Guide](../getting-started)
diff --git a/ej2-react/ai-assistview/speech/speech-to-text.md b/ej2-react/ai-assistview/speech/speech-to-text.md
new file mode 100644
index 000000000..a26a0b39f
--- /dev/null
+++ b/ej2-react/ai-assistview/speech/speech-to-text.md
@@ -0,0 +1,42 @@
+---
+layout: post
+title: Speech-to-Text With React AI AssistView component | Syncfusion
+description: Checkout and learn about configuration of Speech-to-Text With Azure OpenAI in React AI AssistView component of Syncfusion Essential JS 2 and more details.
+platform: ej2-react
+control: AI AssistView
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# Speech-to-Text in React AI AssistView
+
+The Syncfusion React AI AssistView component supports `Speech-to-Text` functionality through the browser's [Web Speech API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Speech_API), enabling conversion of spoken words into text using the device's microphone.
+
+## Prerequisites
+
+Before integrating `Speech-to-Text`, ensure the following:
+
+1. The Syncfusion AI AssistView component is properly set up in your React application.
+ - [React Getting Started Guide](../getting-started)
+
+2. The AI AssistView component is integrated with [Azure OpenAI](https://microsoft.github.io/PartnerResources/skilling/ai-ml-academy/resources/openai).
+ - [Integration of Azure OpenAI With React AI AssistView component](../ai-integrations/openai-integration.md)
+
+## Configure Speech-to-Text
+
+To enable Speech-to-Text functionality, modify the `src/App.jsx` or `src/App.tsx` file to incorporate the Web Speech API. The [SpeechToText](https://ej2.syncfusion.com/react/documentation/speech-to-text/getting-started) component listens for microphone input, transcribes spoken words, and updates the AI AssistView's editable footer with the transcribed text. The transcribed text is then sent as a prompt to the Azure OpenAI service via the AI AssistView component.
+
+{% tabs %}
+{% highlight js tabtitle="app.jsx" %}
+{% include code-snippet/ai-assistview/speech/stt/app/index.jsx %}
+{% endhighlight %}
+{% highlight ts tabtitle="app.tsx" %}
+{% include code-snippet/ai-assistview/speech/stt/app/index.tsx %}
+{% endhighlight %}
+{% endtabs %}
+
+{% previewsample "page.domainurl/code-snippet/ai-assistview/speech/stt" %}
+
+## See Also
+
+* [Text-to-Speech](./text-to-speech.md)
diff --git a/ej2-react/ai-assistview/speech/text-to-speech.md b/ej2-react/ai-assistview/speech/text-to-speech.md
new file mode 100644
index 000000000..002829f42
--- /dev/null
+++ b/ej2-react/ai-assistview/speech/text-to-speech.md
@@ -0,0 +1,42 @@
+---
+layout: post
+title: Text-to-Speech With React AI AssistView component | Syncfusion
+description: Checkout and learn about configuration of Text-to-Speech With Azure OpenAI in React AI AssistView component of Syncfusion Essential JS 2 and more details.
+platform: ej2-react
+control: AI AssistView
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# Text-to-Speech in React AI AssistView
+
+The Syncfusion React AI AssistView component supports `Text-to-Speech` (TTS) functionality using the browser's Web Speech API specifically using the [SpeechSynthesisUtterance](https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesisUtterance) interface to convert AI-generated response into spoken audio.
+
+## Prerequisites
+
+Before integrating `Text-to-Speech`, ensure the following:
+
+1. The Syncfusion AI AssistView component is properly set up in your React application.
+ - [React Getting Started Guide](../getting-started)
+
+2. The AI AssistView component is integrated with [Azure OpenAI](https://microsoft.github.io/PartnerResources/skilling/ai-ml-academy/resources/openai).
+ - [Integration of Azure OpenAI With React AI AssistView component](../ai-integrations/openai-integration.md)
+
+## Configure Text-to-Speech
+
+To enable Text-to-Speech functionality, modify the `src/App.jsx` or `src/App.tsx` file to incorporate the Web Speech API. A custom `Read Aloud` button is added to the response toolbar using the [responseToolbarSettings](https://ej2.syncfusion.com/react/documentation/api/ai-assistview/#responsetoolbarsettings) property. When clicked, the [itemClicked](https://ej2.syncfusion.com/react/documentation/api/ai-assistview/responseToolbarSettings/#itemclicked) event extracts plain text from the generated AI response and use the browser SpeechSynthesis API to read it aloud.
+
+{% tabs %}
+{% highlight js tabtitle="app.jsx" %}
+{% include code-snippet/ai-assistview/speech/tts/app/index.jsx %}
+{% endhighlight %}
+{% highlight ts tabtitle="app.tsx" %}
+{% include code-snippet/ai-assistview/speech/tts/app/index.tsx %}
+{% endhighlight %}
+{% endtabs %}
+
+{% previewsample "page.domainurl/code-snippet/ai-assistview/speech/tts" %}
+
+## See Also
+
+* [Speech-to-Text](./speech-to-text.md)
diff --git a/ej2-react/ai-coding-assistants/copilot-extension.md b/ej2-react/ai-coding-assistants/copilot-extension.md
index d59e34e51..022afa1fc 100644
--- a/ej2-react/ai-coding-assistants/copilot-extension.md
+++ b/ej2-react/ai-coding-assistants/copilot-extension.md
@@ -1,3 +1,4 @@
+<<<<<<< HEAD
---
layout: post
title: SyncfusionReact GitHub Copilot Extension | Syncfusion
@@ -98,3 +99,105 @@ To remove the extension from your account:
* [Syncfusion® React Documentation](https://ej2.syncfusion.com/react/documentation)
* [Github Copilot Documentation](https://docs.github.com/en/copilot)
+=======
+---
+layout: post
+title: SyncfusionReact GitHub Copilot Extension | Syncfusion
+description: Learn how the SyncfusionReact GitHub Copilot extension enhances your React development with intelligent code suggestions, best practices, contextual guidance.
+control: Getting started with SyncfusionReact copilot extension
+platform: ej2-react
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# SyncfusionReact GitHub Copilot Extension
+
+## Overview
+
+The [SyncfusionReact GitHub Copilot Extension](https://github.com/apps/syncfusionreact) provides intelligent assistance for developers using Syncfusion's React component libraries. This extension seamlessly integrates with GitHub Copilot to enhance your development workflow.
+
+### What is a GitHub Copilot Extension?
+
+A GitHub Copilot extension enhances Copilot's capabilities by integrating specialized, third-party tools and knowledge directly into the chat interface. It allows Copilot to access specific data, APIs, and services—such as a component vendor's official documentation—to provide more accurate, context-aware, and relevant assistance for a developer's specific technology stack.
+
+### Key Benefits
+
+* Smart code suggestions for Syncfusion® React components.
+* Best practice guidance for component usage and configuration.
+* Context-aware troubleshooting for complex scenarios.
+
+## Prerequisites
+
+Before using this extension, ensure you have:
+
+* [Github copilot](https://github.com/copilot/)
+* An active Syncfusion® license (any of the following):
+ - [Commercial License](https://www.syncfusion.com/sales/unlimitedlicense)
+ - [Free Community License](https://www.syncfusion.com/products/communitylicense)
+ - [Free Trial](https://www.syncfusion.com/account/manage-trials/start-trials)
+* An active [API KEY](https://syncfusion.com/account/api-key)
+
+## Unlimited Access
+
+Syncfusion® offers unlimited access to this copilot extension. There are no restrictions on:
+
+* Number of requests
+* Components usage
+* Query types
+* Usage duration
+
+This ensures users can fully leverage Syncfusion® components to enhance their development experience without limitations.
+
+## Installation
+
+* Visit the [SyncfusionReact GitHub App](https://github.com/apps/syncfusionreact) and click **Install**.
+* Grant the required read-access permissions to allow the extension to function with Copilot chat.
+* Click **Install & Authorize**.
+* Sign in with your Syncfusion® account to authenticate and link the extension to your GitHub account. The API key is automatically retrieved upon successful authentication.
+* Restart your development environment (e.g., VS Code or GitHub Copilot) and start a new Copilot chat session to use the extension.
+
+## Getting Started
+
+* Open the chat panel in a supported environment like [GitHub Copilot](https://github.com/copilot) or VSCode Copilot.
+* Type `@` in the chat prompt and select the `SyncfusionReact` from the list of extensions.
+* Enter a query related to Syncfusion® React components (e.g., configuration, implementation, or troubleshooting).
+
+### Mode availability in VS code
+
+Syncfusion® Copilot extension provide full access to all AI interaction modes — Ask, Edit, and Agent — when integrated with VS code.
+
+### Best Practices for Effective Usage
+
+1. `Be specific`: Mention both platform and component (e.g., "How do I create a Syncfusion React Grid with paging and filtering?").
+2. `Provide context`: Include details about your use case for more targeted solutions.
+3. `Use descriptive queries`: Avoid vague questions that lack necessary context.
+4. `Start fresh for new topics`: Begin a new chat session when switching components or topics.
+
+## Example Queries
+
+Here are some examples of queries you can use with the Syncfusion® Copilot extensions:
+
+* "@SyncfusionReact Create a Syncfusion data grid with paging and sorting"
+* "@SyncfusionReact How do I implement a responsive Syncfusion chart with tooltips?"
+* "@SyncfusionReact Show me a Syncfusion Kanban board implementation with drag and drop"
+
+## Uninstallation
+
+To remove the extension from your account:
+
+* Go to [GitHub App Installations](https://github.com/settings/installations/).
+* Locate the `SyncfusionReact` extension in the list.
+* Click `Configure`, then select `Uninstall`.
+
+## Support
+
+* [Support tickets](https://support.syncfusion.com/support/tickets/create) - Guaranteed Response in 24 hours \| Unlimited tickets \| Holiday support
+* [Community forum](https://www.syncfusion.com/forums/essential-js2)
+* [Request feature or report bug](https://www.syncfusion.com/feedback/javascript)
+* Live chat
+
+## See also
+
+* [Syncfusion® React Documentation](https://ej2.syncfusion.com/react/documentation)
+* [Github Copilot Documentation](https://docs.github.com/en/copilot)
+>>>>>>> remotes/origin/development
diff --git a/ej2-react/ai-coding-assistants/mcp-server.md b/ej2-react/ai-coding-assistants/mcp-server.md
index 0a1e81750..360d10d9e 100644
--- a/ej2-react/ai-coding-assistants/mcp-server.md
+++ b/ej2-react/ai-coding-assistants/mcp-server.md
@@ -1,3 +1,4 @@
+<<<<<<< HEAD
---
layout: post
title: SyncfusionReactAssistant MCP Server | Syncfusion
@@ -210,3 +211,217 @@ Product support is available through the following mediums.
## See also
* [Syncfusion React Documentation](https://ej2.syncfusion.com/react/documentation)
+=======
+---
+layout: post
+title: SyncfusionReactAssistant MCP Server | Syncfusion
+description: Learn how to configure and use SyncfusionReactAssistant MCP server for intelligent code generation, documentation, and troubleshooting in React apps.
+control: Getting started with SyncfusionReactAssistant MCP Server
+platform: ej2-react
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# SyncfusionReactAssistant MCP Server
+
+## Overview
+
+The [SyncfusionReactAssistant](https://www.npmjs.com/package/@syncfusion/react-assistant) is a specialized [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) server that provides intelligent assistance for developers using Syncfusion's React component libraries. This tool seamlessly integrates with compatible [MCP clients](https://modelcontextprotocol.io/clients) to enhance your development workflow when building React applications with Syncfusion® components.
+
+### Key Benefits
+
+* Intelligent code generation for Syncfusion® React components.
+* Detailed component documentation and usage examples.
+* Troubleshooting assistance for common integration challenges.
+
+## Prerequisites
+
+Before using [SyncfusionReactAssistant](https://www.npmjs.com/package/@syncfusion/react-assistant), ensure you have:
+
+* Required [node](https://nodejs.org/en/) version >= 18
+* A [compatible MCP client](https://modelcontextprotocol.io/clients) (VS Code with GitHub Copilot, [Syncfusion® CodeStudio](https://www.syncfusion.com/code-studio/), etc.)
+* An active Syncfusion® license (any of the following):
+ - [Commercial License](https://www.syncfusion.com/sales/unlimitedlicense)
+ - [Free Community License](https://www.syncfusion.com/products/communitylicense)
+ - [Free Trial](https://www.syncfusion.com/account/manage-trials/start-trials)
+* An active [API KEY](https://syncfusion.com/account/api-key)
+
+## Unlimited Access
+
+Syncfusion® offers unlimited access to this MCP server. There are no restrictions on:
+
+* Number of requests
+* Components usage
+* Query types
+* Usage duration
+
+This ensures users can fully leverage Syncfusion® components to enhance their development experience without limitations.
+
+## Installation and setup
+
+Before you can invoke the `SyncfusionReactAssistant` MCP server, you need to configure your MCP client with these core settings. The **Generic MCP Server Settings** shown below are identical across all clients:
+
+### Generic MCP Server Settings
+
+- **npm package name**: `@syncfusion/react-assistant`
+- **Type**: stdio (standard input/output transport)
+- **Command**: npx
+- **Arguments**: -y
+- **Server name**: syncfusionReactAssistant
+
+You need to add your [Syncfusion API key](https://syncfusion.com/account/api-key) as an env parameter in the configuration file:
+
+```json
+"env": {
+ "Syncfusion_API_Key": "YOUR_API_KEY"
+}
+```
+
+[SyncfusionReactAssistant](https://www.npmjs.com/package/@syncfusion/react-assistant) can be configured in various MCP clients. Below are setup instructions for popular environment:
+
+### Syncfusion® Code Studio
+
+* In [Code Studio](https://www.syncfusion.com/code-studio/), open MCP Marketplace and navigate to the `Custom Servers` tab.
+* Enter the Server Name as `react-mcp`, choose Server Type as npm package, and set the NPM Package name to `@syncfusion/react-assistant`.
+* Add an environment variable as `Syncfusion_API_Key` and value as your [Syncfusion API key](https://syncfusion.com/account/api-key), then click **Install Server**.
+* Once installed, the server will appear in the User Installed Server list, and will be added to the **config.yaml** file.
+* The server is now ready for use in Code Studio. For more details, refer to the Code Studio [documentation](https://help.syncfusion.com/code-studio/reference/configure-properties/mcp/customservers#npm-server).
+
+### VS Code (GitHub Copilot MCP)
+
+1. To configure an MCP server for a specific workspace, you can create a `.vscode/mcp.json` file in your workspace folder.
+
+```json
+{
+ "servers": {
+ "syncfusion-react-assistant": {
+ "type": "stdio",
+ "command": "npx",
+ "args": [
+ "-y",
+ "@syncfusion/react-assistant@latest"
+ ],
+ "env": {
+ "Syncfusion_API_Key": "YOUR_API_KEY"
+ }
+ }
+ }
+}
+```
+
+2. After updating the configuration in settings.json, you'll notice a "Start" option at the top of the config. This allows you to easily start the [SyncfusionReactAssistant](https://www.npmjs.com/package/@syncfusion/react-assistant) server directly from the settings interface without additional commands.
+
+3. Confirm that [SyncfusionReactAssistant](https://www.npmjs.com/package/@syncfusion/react-assistant) is being used (this does not happen automatically). Look for a statement in the output, which is similar to:
+ * `SyncfusionReactAssistant is running...` (in VS Code)
+
+### Cursor
+
+To configure an MCP server for a specific workspace, you can create a .cursor/mcp.json file in your workspace folder.
+
+```json
+{
+ "mcpServers": {
+ "syncfusion-react-assistant": {
+ "type": "stdio",
+ "command": "npx",
+ "args": [
+ "-y",
+ "@syncfusion/react-assistant@latest"
+ ],
+ "env": {
+ "Syncfusion_API_Key": "YOUR_API_KEY"
+ }
+ }
+ }
+}
+```
+
+### JetBrains IDEs
+
+1. Go to Settings -> Tools -> AI Assistant -> Model Context Protocol (MCP).
+2. Click + Add to add a new MCP server configuration.
+3. In the New MCP Server dialog, switch the dropdown as `As JSON` and add the following config:
+
+```json
+{
+ "mcpServers": {
+ "syncfusion-react-assistant": {
+ "command": "npx",
+ "args": [
+ "-y",
+ "@syncfusion/react-assistant@latest"
+ ],
+ "env": {
+ "Syncfusion_API_Key": "YOUR_API_KEY"
+ }
+ }
+ }
+}
+```
+
+4. Click OK and Apply.
+
+> For more detailed information about configuring MCP servers in various clients, refer to the official documentations.
+ * [VS Code](https://code.visualstudio.com/docs/copilot/chat/mcp-servers#_add-an-mcp-server)
+ * [Cursor](https://docs.cursor.com/en/context/mcp#using-mcp-json)
+ * [JetBrains](https://www.jetbrains.com/help/ai-assistant/mcp.html#connect-to-an-mcp-server)
+ * [Windsurf](https://docs.windsurf.com/windsurf/cascade/mcp#mcp-config-json)
+
+## Usage
+
+To activate the SyncfusionReactAssistant MCP server:
+
+1. Start your prompt with one of the following:
+ * 'SyncfusionReactAssistant'
+ * '/syncfusion-react-assistant'
+ * '/syncfusion-react'
+ * '@syncfusion-react'
+ * '@ask_syncfusion_react'
+ * 'ej2-react'
+
+ In VS Code, you can also use #SyncfusionReactAssistant to explicitly invoke the MCP server.
+
+2. Grant the SyncfusionReactAssistant MCP server a permission to run for this session, workspace, or always.
+3. For best results, start a new chat for each new topic to maintain clean context.
+
+### Mode availability
+
+Syncfusion® MCP Servers provide full access to all AI interaction modes — Ask/Chat, Edit, and Agent — across supported MCP clients.
+
+### Best Practices for Effective Usage
+
+1. `Be specific`: Mention both platform and component (e.g., "How do I create a Syncfusion React Grid with paging and filtering?").
+2. `Provide context`: Include details about your use case for more targeted solutions.
+3. `Use descriptive queries`: Avoid vague questions that lack necessary context.
+4. `Start fresh for new topics`: Begin a new chat session when switching components or topics.
+
+### Example Queries
+
+Here are some effective ways to use [SyncfusionReactAssistant](https://www.npmjs.com/package/@syncfusion/react-assistant):
+
+ * "Create a Syncfusion React Grid component with paging, sorting and filtering"
+ * "How do I implement data binding with Syncfusion React scheduler?"
+ * "Show me how to create a dashboard with multiple Syncfusion components"
+
+## Troubleshooting
+
+If you encounter issues:
+
+ * Verify your API key is correctly configured.
+ * Ensure the MCP server is enabled in your client's tools selection.
+ * Check that you're using a compatible MCP client version.
+ * Try restarting your development environment.
+
+## Support
+
+Product support is available through the following mediums.
+
+* [Support ticket](https://support.syncfusion.com/support/tickets/create) - Guaranteed Response in 24 hours \| Unlimited tickets \| Holiday support
+* [Community forum](https://www.syncfusion.com/forums/essential-js2)
+* [Request feature or report bug](https://www.syncfusion.com/feedback/javascript)
+* Live chat
+
+## See also
+
+* [Syncfusion React Documentation](https://ej2.syncfusion.com/react/documentation)
+>>>>>>> remotes/origin/development
diff --git a/ej2-react/ai-coding-assistants/overview.md b/ej2-react/ai-coding-assistants/overview.md
index 4e5f2aa89..d96619e6f 100644
--- a/ej2-react/ai-coding-assistants/overview.md
+++ b/ej2-react/ai-coding-assistants/overview.md
@@ -1,3 +1,4 @@
+<<<<<<< HEAD
---
layout: post
title: Syncfusion AI Coding Assistant Overview | Syncfusion
@@ -71,3 +72,78 @@ The Syncfusion® AI Coding Assistant is desi
* Add the [SyncfusionReactAssistant MCP Server](https://ej2.syncfusion.com/react/documentation/ai-coding-assistants/mcp-server) to an MCP-enabled client
* Install the [SyncfusionReact GitHub Copilot Extension](https://ej2.syncfusion.com/react/documentation/ai-coding-assistants/copilot-extension)
* [Syncfusion® React Documentation](https://ej2.syncfusion.com/react/documentation)
+=======
+---
+layout: post
+title: Syncfusion AI Coding Assistant Overview | Syncfusion
+description: Learn how Syncfusion AI Coding Assistant boost React productivity by generating accurate code snippets, configuration examples, and contextual guidance.
+control: Syncfusion AI Coding Assistant Overview
+platform: ej2-react
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# Syncfusion® AI Coding Assistant Overview
+
+The **Syncfusion® AI Coding Assistant** are designed to streamline your development workflow when building React applications with Syncfusion® components. It uses contextual knowledge of the Syncfusion® component library to generate accurate code snippets, configuration examples, and guided explanations—minimizing documentation searches and maximizing productivity.
+
+AI Coding Assistant:
+
+* **The SyncfusionReactAssistant MCP Server**
+ Processes advanced prompts and returns tailored code suggestions via [MCP-compatible clients](https://modelcontextprotocol.io/clients).
+* **SyncfusionReact GitHub Copilot Extension**
+ Augments GitHub Copilot with Syncfusion-specific support for rapid component setup and contextual guidance in the IDE.
+
+## Getting Started
+
+To use the AI Coding Assistant, you need:
+
+* A [Syncfusion® user account](https://www.syncfusion.com/account)
+* An active Syncfusion® license (any of the following):
+ - [Commercial License](https://www.syncfusion.com/sales/unlimitedlicense)
+ - [Free Community License](https://www.syncfusion.com/products/communitylicense)
+ - [Free Trial](https://www.syncfusion.com/account/manage-trials/start-trials)
+* An active [API KEY](https://syncfusion.com/account/api-key)
+* A [React application that includes SyncfusionReact](https://ej2.syncfusion.com/react/documentation/getting-started/quick-start)
+
+## Unlimited Access
+
+Syncfusion® offers unlimited access to the AI Coding Assistant, with no limitations on:
+
+* Number of requests
+* Components usage
+* Query types
+* Usage duration
+
+This ensures users can fully leverage Syncfusion® components to enhance their development experience without limitations.
+
+## Best Practices
+
+* Initial Setup: Use the tools to quickly add and configure Syncfusion® components in your React application.
+* Feature Tuning: Enable or disable component features through prompt-based configuration for tailored functionality.
+* Data Binding: Generate sample data for testing and prototyping. Avoid using sensitive or production data to ensure security.
+* Step-by-step explanations: Use annotated code to understand component behavior. Note that the level of detail may vary depending on the tool, mode, and AI model used. Refer to the [Syncfusion® React Documentation](https://ej2.syncfusion.com/react/documentation) for in-depth information.
+* Troubleshooting: Resolve common issues with AI-generated suggestions. For complex problems, refer to [documentation](https://ej2.syncfusion.com/react/documentation) or [support](https://support.syncfusion.com/support/tickets/create).
+
+> Always check AI-generated content and code for accuracy before using it.
+
+## Recommendations
+
+* Session Management: Start new sessions when switching tasks to ensure prompt relevance and maintain content focus.
+* Model Compatibility: For optimal performance, use the tools with advanced AI models such as GPT-5 or Claude Sonnet 4.
+
+## Privacy & Data Handling
+
+The Syncfusion® AI Coding Assistant is designed with privacy in mind:
+
+* The tools do not access your project files or workspace directly.
+* User prompts are not stored by any of the tools or used for any other purpose.
+* Prompts are not used to train Syncfusion® models.
+* The assistant generates context, while the final output is handled by your selected AI model.
+
+## See also
+
+* Add the [SyncfusionReactAssistant MCP Server](https://ej2.syncfusion.com/react/documentation/ai-coding-assistants/mcp-server) to an MCP-enabled client
+* Install the [SyncfusionReact GitHub Copilot Extension](https://ej2.syncfusion.com/react/documentation/ai-coding-assistants/copilot-extension)
+* [Syncfusion® React Documentation](https://ej2.syncfusion.com/react/documentation)
+>>>>>>> remotes/origin/development
diff --git a/ej2-react/chart/chart-types/area.md b/ej2-react/chart/chart-types/area.md
index 26b8d6da6..942d5df5a 100644
--- a/ej2-react/chart/chart-types/area.md
+++ b/ej2-react/chart/chart-types/area.md
@@ -278,6 +278,11 @@ The [`pointRender`](https://ej2.syncfusion.com/react/documentation/api/chart/iPo
## See Also
+<<<<<<< HEAD
* [Data label](./data-labels)
* [Tooltip](./tool-tip)
+=======
+* [Data label](./data-labels/)
+* [Tooltip](./tool-tip/)
+>>>>>>> remotes/origin/development
* [Use SVG Linear Gradient](https://support.syncfusion.com/kb/article/21513/how-to-use-svg-linear-gradient-for-react-area-chart-with-css)
\ No newline at end of file
diff --git a/ej2-react/chart/chart-types/bar.md b/ej2-react/chart/chart-types/bar.md
index 26a25a608..5b1a88667 100644
--- a/ej2-react/chart/chart-types/bar.md
+++ b/ej2-react/chart/chart-types/bar.md
@@ -406,6 +406,11 @@ The [`pointRender`](https://ej2.syncfusion.com/react/documentation/api/chart/iPo
## See also
+<<<<<<< HEAD
* [Data label](./data-labels)
* [Tooltip](./tool-tip)
+=======
+* [Data label](./data-labels/)
+* [Tooltip](./tool-tip/)
+>>>>>>> remotes/origin/development
* [Color a Particular Bar](https://support.syncfusion.com/kb/article/21515/how-to-color-a-particular-bar-in-react-chart-component)
\ No newline at end of file
diff --git a/ej2-react/chart/data-labels.md b/ej2-react/chart/data-labels.md
index c7e7d0ac2..4447a00ef 100644
--- a/ej2-react/chart/data-labels.md
+++ b/ej2-react/chart/data-labels.md
@@ -282,6 +282,11 @@ You can calculate the percentage value based on the sum for each series using th
## See Also
+<<<<<<< HEAD
* [Show total stacking values in data label](./how-to#show-the-total-value-for-stacking-series-in-data-label)
* [Prevent the data label when the data value is 0](./how-to#prevent-the-data-label-when-the-data-value-is-0)
+=======
+* [Show total stacking values in data label](./how-to/#show-the-total-value-for-stacking-series-in-data-label)
+* [Prevent the data label when the data value is 0](./how-to/#prevent-the-data-label-when-the-data-value-is-0)
+>>>>>>> remotes/origin/development
* [Display Data Labels in Lakh](https://support.syncfusion.com/kb/article/21250/how-to-display-data-labels-in-lakh-in-react-accumulation-chart)
\ No newline at end of file
diff --git a/ej2-react/chart/data-markers.md b/ej2-react/chart/data-markers.md
index a3ffd2212..b095907d5 100644
--- a/ej2-react/chart/data-markers.md
+++ b/ej2-react/chart/data-markers.md
@@ -146,5 +146,10 @@ Marker can be filled with the series color by setting the [`isFilled`](https://e
## See Also
+<<<<<<< HEAD
* [Customize the marker with different shape](./how-to#customize-the-marker-with-different-shape)
-* [Highlight a Marker in Multicolored Line Series](https://support.syncfusion.com/kb/article/21514/how-to-highlight-a-specific-marker-in-a-multicolored-line-series-in-react-chart)
\ No newline at end of file
+* [Highlight a Marker in Multicolored Line Series](https://support.syncfusion.com/kb/article/21514/how-to-highlight-a-specific-marker-in-a-multicolored-line-series-in-react-chart)
+=======
+* [Customize the marker with different shape](./how-to/#customize-the-marker-with-different-shape)
+* [Highlight a Marker in Multicolored Line Series](https://support.syncfusion.com/kb/article/21514/how-to-highlight-a-specific-marker-in-a-multicolored-line-series-in-react-chart)
+>>>>>>> remotes/origin/development
diff --git a/ej2-react/chart/legend.md b/ej2-react/chart/legend.md
index 4978cecba..d48ce47f1 100644
--- a/ej2-react/chart/legend.md
+++ b/ej2-react/chart/legend.md
@@ -400,5 +400,9 @@ The [`layout`](https://ej2.syncfusion.com/react/documentation/api/chart/legendSe
## See Also
+<<<<<<< HEAD
* [Customize each shape in legend](./how-to#customize-each-shape-in-legend)
+=======
+* [Customize each shape in legend](./how-to/#customize-each-shape-in-legend)
+>>>>>>> remotes/origin/development
* [Add Custom Legend Using SVG](https://support.syncfusion.com/kb/article/21530/how-to-add-custom-legend-using-svg-in-react-chart)
\ No newline at end of file
diff --git a/ej2-react/chat-ui/messages.md b/ej2-react/chat-ui/messages.md
index 658baa492..a071807eb 100644
--- a/ej2-react/chat-ui/messages.md
+++ b/ej2-react/chat-ui/messages.md
@@ -349,7 +349,7 @@ The Chat UI component supports `Markdown` formatting for messages, enabling rich
To enable Markdown rendering, a third-party library that converts Markdown syntax to HTML is required.
-- Include the `marked` library:
+- Include the `marked` library:
```bash
diff --git a/ej2-react/code-snippet/ai-assistview/ai-integrations/gemini-ai/app/index.jsx b/ej2-react/code-snippet/ai-assistview/ai-integrations/gemini-ai/app/index.jsx
index 992da505b..c529a1da3 100644
--- a/ej2-react/code-snippet/ai-assistview/ai-integrations/gemini-ai/app/index.jsx
+++ b/ej2-react/code-snippet/ai-assistview/ai-integrations/gemini-ai/app/index.jsx
@@ -15,6 +15,10 @@ function App() {
'How can I improve my time management skills?'
];
const bannerTemplate = '
How can I help you today?
';
+<<<<<<< HEAD
+=======
+
+>>>>>>> remotes/origin/development
const toolbarItemClicked = (args) => {
if (args.item.iconCss === 'e-icons e-refresh') {
assistInstance.current.prompts = [];
@@ -47,7 +51,11 @@ function App() {
};
const onPromptRequest = (args) => {
+<<<<<<< HEAD
const model = genAI.getGenerativeModel({ model: 'gemini-2.5-flash' }); //Replace Your Model Name Here
+=======
+ const model = genAI.getGenerativeModel({ model: 'gemini-2.5-flash' }); // Replace Your Model Name Here
+>>>>>>> remotes/origin/development
model.generateContent(args.prompt)
.then(result => {
const responseText = result.response.text().trim() || 'No respons received.';
diff --git a/ej2-react/code-snippet/ai-assistview/ai-integrations/gemini-ai/app/index.tsx b/ej2-react/code-snippet/ai-assistview/ai-integrations/gemini-ai/app/index.tsx
index 89fd2c73d..ebdddbe68 100644
--- a/ej2-react/code-snippet/ai-assistview/ai-integrations/gemini-ai/app/index.tsx
+++ b/ej2-react/code-snippet/ai-assistview/ai-integrations/gemini-ai/app/index.tsx
@@ -15,7 +15,12 @@ function App() {
'How do I prioritize my tasks?',
'How can I improve my time management skills?'
];
+<<<<<<< HEAD
const bannerTemplate = '
How can I help you today?
';
+=======
+ const bannerTemplate: string = '
How can I help you today?
';
+
+>>>>>>> remotes/origin/development
const toolbarItemClicked = (args: ToolbarItemClickArgs): void => {
if (args.item.iconCss === 'e-icons e-refresh') {
if (assistInstance.current) {
@@ -52,7 +57,11 @@ function App() {
};
const onPromptRequest = (args: { prompt: string }): void => {
+<<<<<<< HEAD
const model = genAI.getGenerativeModel({ model: 'gemini-2.5-flash' }); //Replace Your Model Name Here
+=======
+ const model = genAI.getGenerativeModel({ model: 'gemini-2.5-flash' }); // Replace Your Model Name Here
+>>>>>>> remotes/origin/development
model.generateContent(args.prompt)
.then((result: GenerateContentResult) => {
const responseText: string = result.response.text().trim() || 'No response received.';
diff --git a/ej2-react/code-snippet/ai-assistview/ai-integrations/llm-model/app/index.jsx b/ej2-react/code-snippet/ai-assistview/ai-integrations/llm-model/app/index.jsx
new file mode 100644
index 000000000..ecd7eb2ee
--- /dev/null
+++ b/ej2-react/code-snippet/ai-assistview/ai-integrations/llm-model/app/index.jsx
@@ -0,0 +1,91 @@
+import { AIAssistViewComponent } from '@syncfusion/ej2-react-interactive-chat';
+import * as React from 'react';
+import * as ReactDOM from "react-dom";
+import { marked } from 'marked';
+
+function App() {
+ const assistInstance = React.useRef(null);
+ let stopStreaming = false;
+ const suggestions = [
+ 'How do I prioritize my tasks?',
+ 'How can I improve my time management skills?'
+ ];
+ const bannerTemplate = '
How can I help you today?
';
+
+ const toolbarItemClicked = (args) => {
+ if (args.item.iconCss === 'e-icons e-refresh') {
+ assistInstance.current.prompts = [];
+ assistInstance.current.promptSuggestions = suggestions;
+ stopStreaming = true;
+ }
+ };
+
+ const assistViewToolbarSettings = {
+ items: [{ iconCss: 'e-icons e-refresh', align: 'Right' }],
+ itemClicked: toolbarItemClicked
+ };
+
+ const streamResponse = async (response) => {
+ let lastResponse = '';
+ const responseUpdateRate = 10;
+ let i = 0;
+ const responseLength = response.length;
+ while (i < responseLength && !stopStreaming) {
+ lastResponse += response[i];
+ i++;
+ if (i % responseUpdateRate === 0 || i === responseLength) {
+ const htmlResponse = marked.parse(lastResponse);
+ assistInstance.current.addPromptResponse(htmlResponse, i === responseLength);
+ assistInstance.current.scrollToBottom();
+ }
+ await new Promise(resolve => setTimeout(resolve, 15)); // Delay for streaming effect
+ }
+ assistInstance.current.promptSuggestions = suggestions;
+ };
+
+ const onPromptRequest = (args) => {
+ const defaultResponse = '⚠️ Something went wrong while connecting to the AI service. Please check your Ollama application running background.';
+ fetch('http://localhost:11434/api/generate', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ model: 'deepseek-r1',
+ prompt: `### Instruction:\nRespond in up to 5 lines.\n\n### Input:\n${args.prompt || 'Hi'}`,
+ stream: false,
+ }),
+ })
+ .then(response => {
+ if (!response.ok) {
+ throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+ }
+ return response.json();
+ })
+ .then(reply => {
+ const responseText = reply.response?.trim() || 'No response received.';
+ stopStreaming = false;
+ streamResponse(responseText);
+ })
+ .catch(error => {
+ assistInstance.current.addPromptResponse(defaultResponse, true);
+ assistInstance.current.promptSuggestions = suggestions;
+ stopStreaming = true;
+ });
+ };
+
+ const handleStopResponse = () => {
+ stopStreaming = true;
+ };
+
+ return (
+
+ );
+}
+ReactDOM.render(, document.getElementById('container'));
diff --git a/ej2-react/code-snippet/ai-assistview/ai-integrations/llm-model/app/index.tsx b/ej2-react/code-snippet/ai-assistview/ai-integrations/llm-model/app/index.tsx
new file mode 100644
index 000000000..3df8566c5
--- /dev/null
+++ b/ej2-react/code-snippet/ai-assistview/ai-integrations/llm-model/app/index.tsx
@@ -0,0 +1,92 @@
+import { AIAssistViewComponent,PromptRequestEventArgs,ToolbarItemClickedEventArgs } from '@syncfusion/ej2-react-interactive-chat';
+import * as React from 'react';
+import * as ReactDOM from "react-dom";
+import { marked } from 'marked';
+
+
+function App() {
+ const assistInstance = React.useRef(null);
+ let stopStreaming:boolean = false;
+ const suggestions: string[] = [
+ 'How do I prioritize my tasks?',
+ 'How can I improve my time management skills?'
+ ];
+ const bannerTemplate = '
+
+
+
+
\ No newline at end of file
diff --git a/ej2-react/code-snippet/ai-assistview/speech/tts/systemjs.config.js b/ej2-react/code-snippet/ai-assistview/speech/tts/systemjs.config.js
new file mode 100644
index 000000000..f8fd474a2
--- /dev/null
+++ b/ej2-react/code-snippet/ai-assistview/speech/tts/systemjs.config.js
@@ -0,0 +1,49 @@
+System.config({
+ transpiler: "ts",
+ typescriptOptions: {
+ target: "es5",
+ module: "commonjs",
+ moduleResolution: "node",
+ emitDecoratorMetadata: true,
+ experimentalDecorators: true,
+ "jsx": "react"
+ },
+ meta: {
+ 'typescript': {
+ "exports": "ts"
+ }
+ },
+ paths: {
+ "syncfusion:": "https://cdn.syncfusion.com/ej2/20.3.56/"
+ },
+ map: {
+ app: 'app',
+ ts: "https://unpkg.com/plugin-typescript@4.0.10/lib/plugin.js",
+ typescript: "https://unpkg.com/typescript@2.2.2/lib/typescript.js",
+ "@syncfusion/ej2-base": "syncfusion:ej2-base/dist/ej2-base.umd.min.js",
+ "@syncfusion/ej2-interactive-chat": "syncfusion:ej2-interactive-chat/dist/ej2-interactive-chat.umd.min.js",
+ "@syncfusion/ej2-inputs": "syncfusion:ej2-inputs/dist/ej2-inputs.umd.min.js",
+ "@syncfusion/ej2-navigations": "syncfusion:ej2-navigations/dist/ej2-navigations.umd.min.js",
+ "@syncfusion/ej2-dropdowns": "syncfusion:ej2-dropdowns/dist/ej2-dropdowns.umd.min.js",
+ "@syncfusion/ej2-notifications": "syncfusion:ej2-notifications/dist/ej2-notifications.umd.min.js",
+ "@syncfusion/ej2-lists": "syncfusion:ej2-lists/dist/ej2-lists.umd.min.js",
+ "@syncfusion/ej2-popups": "syncfusion:ej2-popups/dist/ej2-popups.umd.min.js",
+ "@syncfusion/ej2-buttons": "syncfusion:ej2-buttons/dist/ej2-buttons.umd.min.js",
+ "@syncfusion/ej2-data": "syncfusion:ej2-data/dist/ej2-data.umd.min.js",
+ "@syncfusion/ej2-splitbuttons": "syncfusion:ej2-splitbuttons/dist/ej2-splitbuttons.umd.min.js",
+ "@syncfusion/ej2-react-base": "syncfusion:ej2-react-base/dist/ej2-react-base.umd.min.js",
+ "@syncfusion/ej2-react-interactive-chat": "syncfusion:ej2-react-interactive-chat/dist/ej2-react-interactive-chat.umd.min.js",
+ "@syncfusion/ej2-react-inputs": "syncfusion:ej2-react-inputs/dist/ej2-react-inputs.umd.min.js",
+ "@syncfusion/ej2-react-navigations": "syncfusion:ej2-react-navigations/dist/ej2-react-navigations.umd.min.js",
+ "@syncfusion/ej2-react-notifications": "syncfusion:ej2-react-notifications/dist/ej2-react-notifications.umd.min.js",
+ "react-dom": "https://unpkg.com/react-dom@18.2.0/umd/react-dom.production.min.js",
+ "react": "https://unpkg.com/react@18.2.0/umd/react.production.min.js",
+ "marked": "https://cdn.jsdelivr.net/npm/marked/marked.min.js",
+ "@google/generative-ai": "https://cdn.jsdelivr.net/npm/@google/generative-ai@0.24.1/dist/index.min.js"
+ },
+ packages: {
+ 'app': { main: 'index', defaultExtension: 'tsx' },
+ }
+});
+
+System.import('app');
\ No newline at end of file
diff --git a/ej2-react/diagram/accessibility.md b/ej2-react/diagram/accessibility.md
index fc68e3406..2284cfe5d 100644
--- a/ej2-react/diagram/accessibility.md
+++ b/ej2-react/diagram/accessibility.md
@@ -1,18 +1,18 @@
---
layout: post
-title: Accessibility in React Diagram component | Syncfusion®
-description: Learn here all about Accessibility in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Accessibility in React Diagram Component | Syncfusion®
+description: Learn here all about Accessibility in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Accessibility
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Accessibility in React Diagram component
+# Accessibility in React Diagram Component
-Diagram provides built-in compliance with the [WAI-ARIA](http://www.w3.org/WAI/PF/aria-practices/) specifications. WAI-ARIA Accessibility supports are achieved through the attributes like `aria-label`. It helps to provides information about elements in a document for assistive technology.
+The Diagram component provides built-in compliance with the [WAI-ARIA](http://www.w3.org/WAI/PF/aria-practices/) specifications. WAI-ARIA accessibility support is achieved through attributes like `aria-label`, which provide information about elements in a document for assistive technologies such as screen readers.
-The accessibility compliance for the diagram component is outlined below.
+The following table outlines accessibility compliance for the Diagram component:
| Accessibility Criteria | Compatibility |
| ----------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
@@ -38,16 +38,16 @@ The accessibility compliance for the diagram component is outlined below.
- The component does not meet the requirement.
-## WAI-ARIA attributes
+## WAI-ARIA Attributes
-The Diagram component followed the [WAI-ARIA](?) patterns to meet the accessibility. The following ARIA attributes are used in the Diagram component:
+The Diagram component follows [WAI-ARIA] patterns to meet accessibility requirements. The following ARIA attributes are used in the Diagram component:
| Attributes | Purpose |
| --- | --- |
| `aria-label` | Provides an accessible name for the Diagram Objects. |
-## Aria-label
-Attribute provides the text label with some default description for below elements in diagram.
+## Aria-Label
+The `aria-label` attribute provides text labels with default descriptions for the following elements in the Diagram component:
@@ -102,45 +102,60 @@ Attribute provides the text label with some default description for below elemen
-### Mobile device support
+### Screen Reader Support
-Syncfusion® Diagram component are more user-friendly and accessible to individuals using mobile devices, including those with disabilities. These are designed to be responsive, adaptable to various screen sizes and orientations, and touch-friendly.
+The Diagram component supports screen readers, and its information is properly conveyed by screen readers based on ARIA attributes and content structure.
+
+### Mobile Device Support
+
+Syncfusion® Diagram component is designed to be user-friendly and accessible on mobile devices, including for users with disabilities. The component is responsive, adapts to various screen sizes and orientations, and provides touch-friendly interactions.
-### Screen Reader Support
-The Diagram component supports and its information was dictated properly by the screen readers based on the ARIA attributes and content.
-### Keyboard navigation support
+### Keyboard Navigation Support
-Syncfusion® Diagram component support keyboard navigation, allowing users who rely on alternate methods to effortlessly navigate and interact with the component.
+Syncfusion® Diagram component supports keyboard navigation, allowing users who rely on assistive technologies to navigate and interact with the component effectively.
-## Keyboard interaction
+## Keyboard Interaction
-The Diagram component followed the [keyboard interaction](https://www.w3.org/WAI/WCAG21/Understanding/keyboard.html) guideline, making it easy for people who use assistive technologies (AT) and those who completely rely on keyboard navigation. The following keyboard shortcuts are supported by the Diagram component.
+The Diagram component follows [keyboard interaction](https://www.w3.org/WAI/WCAG21/Understanding/keyboard.html) guidelines, making it accessible for users who rely on keyboard navigation. The following keyboard shortcuts are supported:
+**Selection and Clipboard Operations**
| **Command** | **Action** |
| --- | --- |
| Ctrl + A | Select All |
| Ctrl + X | Cut |
-| Ctrl + C |Copy |
+| Ctrl + C | Copy |
| Ctrl + V | Paste |
+
+**Edit Operations**
+| **Command** | **Action** |
+| --- | --- |
| Ctrl + Z | Undo |
| Ctrl + Y | Redo |
| Delete | Delete |
+
+**Navigation and Movement**
+| **Command** | **Action** |
+| --- | --- |
| Up Arrow | Move selected object to up |
| Down Arrow | Move selected object to down |
| Left Arrow | Move selected object to left |
| Right Arrow | Move selected object to right |
+
+**Annotation Editing**
+| **Command** | **Action** |
+| --- | --- |
| Enter | Start Annotation Edit |
| Escape | End Annotation Edit |
-## Ensuring accessibility
+## Ensuring Accessibility
-The Diagram component's accessibility levels are ensured through an [accessibility-checker](https://www.npmjs.com/package/accessibility-checker) and [axe-core](https://www.npmjs.com/package/axe-core) software tools during automated testing.
+The Diagram component's accessibility levels are validated through [accessibility-checker](https://www.npmjs.com/package/accessibility-checker) and [axe-core](https://www.npmjs.com/package/axe-core) software tools during automated testing.
-The accessibility compliance of the Diagram component is shown in the following sample. Open the [sample](https://ej2.syncfusion.com/accessibility/diagram.html) in a new window to evaluate the accessibility of the Diagram component with accessibility tools.
+The accessibility compliance of the Diagram component is demonstrated in the following sample. Open the [sample](https://ej2.syncfusion.com/accessibility/diagram.html) in a new window to evaluate the accessibility of the Diagram component with accessibility tools.
## See also
diff --git a/ej2-react/diagram/automatic-layout.md b/ej2-react/diagram/automatic-layout.md
index 97432b321..70c89e012 100644
--- a/ej2-react/diagram/automatic-layout.md
+++ b/ej2-react/diagram/automatic-layout.md
@@ -1,18 +1,19 @@
---
layout: post
-title: Automatic layout in React Diagram component | Syncfusion®
-description: Learn here all about Automatic layout in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Automatic layout in React Diagram Component | Syncfusion®
+description: Learn here all about Automatic layout in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Automatic layout
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Automatic layout in React Diagram component
+# Automatic Layout in React Diagram Component
-Diagram provides support to auto-arrange the nodes in the diagram area that is referred as `Layout`. It includes the following layout modes:
+The Diagram component provides comprehensive support for automatically arranging nodes in the diagram area through various layout algorithms. These automatic layouts help organize complex diagrams by positioning nodes and connectors according to predefined patterns and relationships, eliminating the need for manual positioning,To enable automatic layout in the React Diagram component, configure the `layout` property of the diagram.
-## Layout modes
+## Layout Modes
+The Diagram component supports multiple layout algorithms, each designed for specific use cases and data structures. Each layout mode provides unique positioning strategies and configuration options.
* Hierarchical layout
* Complex hierarchical tree layout
diff --git a/ej2-react/diagram/bezier-controlPoint.md b/ej2-react/diagram/bezier-controlPoint.md
index 0cd7a6d87..8a6e5433c 100644
--- a/ej2-react/diagram/bezier-controlPoint.md
+++ b/ej2-react/diagram/bezier-controlPoint.md
@@ -1,18 +1,20 @@
---
layout: post
-title: Bezier control points interaction in React Diagram component | Syncfusion®
-description: Learn here all about Connectors in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Bezier Control Points Interaction in React Diagram Component | Syncfusion®
+description: Learn how to interact with bezier control points, configure smoothness settings, and control visibility in Syncfusion® React Diagram Component.
control: Bezier control points interaction
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Bezier Control points
+# Bezier Control Points Interaction
-## How to interact with the bezier segments efficiently
+Bezier control points determine the curvature and shape of bezier connector segments in React Diagram components. These interactive handles allow users to modify connector paths dynamically while maintaining visual consistency across multiple segments.
-While interacting with multiple bezier segments, maintain their control points at the same distance and angle by using the bezierSettings smoothness property of the connector class.
+## Configure Bezier Segment Smoothness
+
+When working with multiple bezier segments, maintain visual consistency by configuring the `smoothness` behavior of control points using the [`bezierSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/bezierSettingsModel/) property of the connector. The `smoothness` property controls how adjacent control points respond when one is modified.
| BezierSmoothness value | Description | Output |
|-------- | -------- | -------- |
@@ -32,9 +34,9 @@ While interacting with multiple bezier segments, maintain their control points a
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5BezierSegment-cs1" %}
-## How to show or hide the bezier segment’s control points
+## How to Show or Hide the Bezier Segment’s Control Points
-By using the [`controlPointsVisibility`](https://ej2.syncfusion.com/react/documentation/api/diagram/controlPointsVisibility/) property of [`bezierSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/bezierSettingsModel/), you can enable or disable the visibility of the bezier segment’s control points.
+Configure which control points are visible during interaction using the [`controlPointsVisibility`](https://ej2.syncfusion.com/react/documentation/api/diagram/controlPointsVisibility/) property within [`bezierSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/bezierSettingsModel/). This property provides granular control over control point display for different connector segments.
| ControlPointsVisibility value | Description | Output |
|-------- | -------- | -------- |
diff --git a/ej2-react/diagram/bezier-segEditOrientation.md b/ej2-react/diagram/bezier-segEditOrientation.md
index 0429ad0cc..c0bb19c77 100644
--- a/ej2-react/diagram/bezier-segEditOrientation.md
+++ b/ej2-react/diagram/bezier-segEditOrientation.md
@@ -1,25 +1,31 @@
---
layout: post
-title: Bezier Segment edit orientation in React Diagram component | Syncfusion®
-description: Learn here all about Connectors in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Bezier Segment edit orientation in React Diagram Component | Syncfusion®
+description: Learn to configure Bezier segment orientation in Syncfusion React Diagram Component for custom curved connectors.
control: Bezier Segment edit orientation
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Bezier Connector Settings
+# Bezier Segment Edit Orientation
-## How to edit bezier segments based on bezier connector settings
+Bezier connectors in diagrams provide smooth, curved connections between nodes with customizable control points. The segment edit orientation feature allows interactive modification of bezier connector segments to achieve the desired visual flow and connection paths.
-The intermediate point of two adjacent bezier segments can be edited interactively based on the [`segmentEditOrientation`](../api/diagram/bezierSegmentEditOrientation/) property of [`bezierSettings`](../api/diagram/bezierSettingsModel/).
+## Interactive Editing of Bezier Segments
+
+The intermediate control points between adjacent bezier segments can be edited interactively during runtime based on the [`segmentEditOrientation`](https://ej2.syncfusion.com/react/documentation/api/diagram/bezierSegmentEditOrientation/) property within the [`bezierSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/bezierSettingsModel/)configuration. This property determines the directional constraints applied when users drag the intermediate points to reshape the connector.
+
+### Segment Edit Orientation Options
+
+The following table describes the available orientation modes and their interactive behavior:
| SegmentEditOrientation value | Description | Output |
|-------- | -------- | -------- |
| Bidirectional |It allows the intermediate points to be dragged in either vertical or horizontal directions. |  |
| Freeform | It allows the intermediate points to be dragged in any direction. |  |
-The following code illustrates how to interact with Bezier efficiently by using the [`smoothness`](../api/diagram/bezierSmoothness/) and `segmentEditOrientation` properties of the `bezierSettings`.
+The following code demonstrates how to configure bezier connectors with interactive segment editing using both the [`smoothness`](https://ej2.syncfusion.com/react/documentation/api/diagram/bezierSmoothness/) property for curve refinement and the `segmentEditOrientation` property for interaction control:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/bpmn-activities.md b/ej2-react/diagram/bpmn-activities.md
index 9195a93c5..4f9911f5f 100644
--- a/ej2-react/diagram/bpmn-activities.md
+++ b/ej2-react/diagram/bpmn-activities.md
@@ -1,25 +1,25 @@
---
layout: post
-title: Bpmn Activity in React Diagram component | Syncfusion®
-description: Learn here all about Bpmn shapes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: BPMN Activity in React Diagram Component | Syncfusion®
+description: Learn about BPMN activity shapes including tasks, subprocesses, loops, compensation, and boundaries in Syncfusion® React Diagram Component.
control: Bpmn Activity
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# BPMN activity in React Diagram component
+# BPMN Activity in React Diagram Component
-## Activity
+## Overview
-The [`activity`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnActivity#BpmnActivity) is the task that is performed in a business process. It is represented by a rounded rectangle.
+BPMN (Business Process Model and Notation) activities represent work performed within a business process. An [`activity`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnActivity#BpmnActivity)appears as a rounded rectangle and serves as the fundamental unit of work in process modeling.
-There are two types of activities. They are listed as follows:
+Activities fall into two main categories:
-* Task: Occurs within a process and it is not broken down to a finer level of detail.
-* Subprocess: Occurs within a process and it is broken down to a finer level of detail.
+* **Task**: A single unit of work that cannot be broken down into smaller components within the process model.
+* **Subprocess**: A compound activity that contains other activities and can be expanded to show additional detail.
-To create a BPMN activity, set the shape as **activity**. You also need to set the type of the BPMN activity by using the activity property of the node. By default, the type of the activity is set as **task**. The following code example illustrates how to create an activity.
+To create a BPMN activity, set the shape property to **activity**. Specify the activity type using the activity property of the node. The default activity type is **task**.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -32,13 +32,9 @@ To create a BPMN activity, set the shape as **activity**. You also need to set t
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5Activity-cs1" %}
-The different activities of BPMN process are listed as follows.
-
-
### Tasks
-The [`task`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnTask#BpmnTask) property of the [`bpmn activity`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnactivitymodel/) allows you to define the type of task such as sending, receiving, user based task, etc. By default, the type property of task is set as **none**. The following code illustrates how to create different types of
-BPMN tasks.
+The [`task`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnTask#BpmnTask) property of the [`bpmn activity`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnactivitymodel/)defines specific task types such as user tasks, service tasks, or message tasks. The default task type is **none**. Different task types indicate the nature of work being performed and who or what performs it.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -64,10 +60,13 @@ The various types of BPMN tasks are tabulated as follows.
| User |  |
| Script |  |
+### Subprocesses
-### Collapsed Subprocess
+Subprocesses represent activities that contain other processes or activities within them. They provide a way to organize complex processes hierarchically and can be expanded or collapsed to show or hide internal details.
-A [`Collapsed Sub-Process`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcessModel/#collapsed) is a group of tasks, which is used to hide or reveal details of additional levels. The following code explains how to create a Collapsed Sub-Process.
+#### Collapsed Subprocess
+
+A [`Collapsed Sub-Process`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcessModel/#collapsed)appears as a single activity but contains additional process details that remain hidden. This approach helps maintain process diagram clarity while preserving detailed information.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -82,7 +81,7 @@ A [`Collapsed Sub-Process`](https://ej2.syncfusion.com/react/documentation/api/d
#### Loop
-[`Loop`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnTask#loop) is a task that is internally being looped. The loop property of task allows you to define the type of loop. The default value for `loop` is **none**.You can define the loop property in subprocess BPMN shape as shown in the following code.
+[`Loop`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnTask#loop) characteristics indicate that an activity repeats until a specified condition is met. The loop property of bpmn activity defines the repetition behavior. The default value is **none**.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -95,7 +94,7 @@ A [`Collapsed Sub-Process`](https://ej2.syncfusion.com/react/documentation/api/d
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5Loop-cs1" %}
-The following table contains various types of BPMN loops.
+The following table shows the available loop types for both tasks and subprocesses:
| Loops | Task | Subprocess |
| -------- | -------- | --------|
@@ -105,9 +104,7 @@ The following table contains various types of BPMN loops.
#### Compensation
-[`Compensation`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnTask#compensation) is triggered, when operation is partially failed and enabled it with the compensation property of the `bpmn activity`.
-By default, the `compensation` is set to false.
-
+[`Compensation`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnTask#compensation) indicates that an activity can undo or compensate for work performed by another activity. This becomes relevant when a process fails after partial completion and requires cleanup activities. Enable compensation using the compensation property of the bpmn activity. The default value is **false**.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
{% include code-snippet/diagram/bpmnShapes/es5Compensation-cs1/app/index.jsx %}
@@ -121,8 +118,7 @@ By default, the `compensation` is set to false.
#### Call
-A [`call`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnTask#call) activity is a global subprocess that is reused at various points of the business flow and set it with the call property of the task.
-By default, the call property is false.
+A [`call`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnTask#call) activity references a global process or subprocess that exists outside the current process definition. This promotes reusable across multiple processes. Enable call activity behavior using the call property of the task. The default value is **false**.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -135,11 +131,11 @@ By default, the call property is false.
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5Call-cs1" %}
-N> This Property is only applicable for task Type activity.
+N> The call property applies only to task-type activities.
#### Adhoc
-An adhoc subprocess is a group of tasks that are executed in any order or skipped in order to fulfill the end condition and set it with the [`adhoc`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcess#adhoc) property of subprocess. By default, the adhoc property is false.
+ An [`adhoc`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcess#adhoc)subprocess contains activities that performers can execute in any order or skip entirely, provided the overall objective is achieved. Enable ad hoc behavior using the adhoc property of the subprocess. The default value is **false**.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -152,10 +148,9 @@ An adhoc subprocess is a group of tasks that are executed in any order or skippe
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5Adhoc-cs1" %}
-## Boundary
-
-Boundary represents the type of task that is being processed. The [`boundary`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcess#boundary) property of subprocess allows you to define the type of boundary. By default, it is set as **default**.
+#### Boundary Types
+The [`boundary`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcess#boundary) property defines the visual boundary style of a subprocess, indicating different subprocess characteristics. The default value is **default**.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
{% include code-snippet/diagram/bpmnShapes/es5Boundary-cs1/app/index.jsx %}
@@ -167,25 +162,26 @@ Boundary represents the type of task that is being processed. The [`boundary`](h
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5Boundary-cs1" %}
-The following table contains various types of BPMN boundaries.
+The following table shows the available boundary types:
| Boundary | Image |
| -------- | -------- |
-| Call |  |
-| Event |  |
-| Default |  |
+| Call |  |
+| Event |  |
+| Default |  |
-#### SubProcess types
+#### SubProcess Types
-The different types of subprocess are as follows:
+BPMN defines two specialized subprocess types for specific business scenarios:
* Event subprocess
* Transaction
-##### Event subprocess
+##### Event Subprocess
-A subprocess is defined as an event subprocess, when it is triggered by an event. An event subprocess is placed within another subprocess which is not part of the normal flow of its parent process. You can set event to a subprocess with the [`event`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnEvent##BpmnEvent) and [`trigger`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnEvent#trigger) property of the subprocess. The [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcess#type) property of subprocess allows you to define the type of subprocess whether it should be event subprocess or transaction subprocess.
+An event subprocess executes when triggered by a specific event rather than following the normal process flow. Event subprocesses reside within other subprocesses but remain outside the main sequence flow until activated.
+Configure an event subprocess using the the [`event`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnEvent##BpmnEvent) and [`trigger`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnEvent#trigger) property of the subprocess. The [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcess#type)property determines whether the subprocess is an event subprocess or transaction subprocess.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
{% include code-snippet/diagram/bpmnShapes/es5EventSub-cs1/app/index.jsx %}
@@ -197,17 +193,15 @@ A subprocess is defined as an event subprocess, when it is triggered by an event
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5EventSub-cs1" %}
-##### Transaction subprocess
-
-* [`transaction`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcess#transaction) is a set of activities that logically belong together, in which all contained activities must complete their parts of the transaction; otherwise the process is undone. The execution result of a transaction is one of Successful Completion, Unsuccessful Completion (Cancel), and Hazard (Exception). The [`events`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcess#events) property of subprocess allows to represent these results as an event attached to the subprocess.
-
-* The event object allows you to define the type of event by which the subprocess will be triggered. The name of the event can be defined to identify the event at runtime.
-
-* The event’s offset property is used to set the fraction/ratio (relative to parent) that defines the position of the event shape.
+##### Transaction Subprocess
-* The trigger property defines the type of the event trigger.
+* [`transaction`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcess#transaction) is a set of activities that logically belong together, in which all contained activities must complete their parts of the transaction; otherwise the process is undone. The execution result of a transaction is one of Successful Completion, Unsuccessful Completion (Cancel), and Hazard (Exception). The `events` property allows representation of these results as events attached to the subprocess. Configure event properties as follows:
-* You can also use define ports and labels to subprocess events by using event’s ports and labels properties.
+* **Event type**: Defines the triggering event type for the subprocess.
+* **Event name**: Identifies the event during runtime.
+* **Offset**: Sets the event shape position relative to the parent (as a fraction/ratio).
+* **Trigger**: Specifies the event trigger type.
+* **Ports and labels**: Define additional interaction points and descriptive text.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/bpmn-dataObject.md b/ej2-react/diagram/bpmn-dataObject.md
index 32bcf1ef6..57fc2cc49 100644
--- a/ej2-react/diagram/bpmn-dataObject.md
+++ b/ej2-react/diagram/bpmn-dataObject.md
@@ -1,18 +1,25 @@
---
layout: post
-title: Bpmn DataObject in React Diagram component | Syncfusion®
-description: Learn here all about Bpmn shapes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: BPMN DataObject in React Diagram Component | Syncfusion®
+description: Learn how to create and configure BPMN data objects including input, output, and collection types in Syncfusion® React Diagram Component.
control: Bpmn DataObject
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# BPMN Data object in React Diagram component
+# BPMN Data Object in React Diagram Component
-## Data Object
+## Overview
-A data object represents information flowing through the process, such as data placed into the process, data resulting from the process, data that needs to be collected, or data that must be stored. To define a [`data object`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnDataObject), set the shape as **DataObject** and the type property defines whether data is an input or an output. You can create multiple instances of data object with the collection property of data.
+A BPMN data object represents information that flows through a business process. Data objects can represent data placed into the process, data resulting from the process, data that needs to be collected, or data that must be stored. In business process modeling, data objects help visualize how information moves through different process activities.
+
+## Creating Data Objects
+To create a BPMN data object in the React Diagram component, set the shape type as [`data object`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnDataObject). The [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnDataObject/#type) property determines whether the data object represents input data, output data, or a collection of data items.
+
+### Basic Data Object Configuration
+
+The following example demonstrates how to create a basic BPMN data object:.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -25,7 +32,20 @@ A data object represents information flowing through the process, such as data p
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5Data-cs1" %}
-The following table contains various representation of BPMN data object.
+## Data Object Types
+
+BPMN data objects support three distinct types, each serving different purposes in process modeling:
+
+### Collection Data Object
+Represents multiple instances of data items. Use this type when the process handles collections of information such as lists, arrays, or multiple documents.
+
+### Data Input
+Represents data that enters the process from external sources. This type indicates information required by the process to execute successfully.
+
+### Data Output
+Represents data generated or modified by the process. This type shows information produced as a result of process execution.
+
+The following table shows the visual representation of each data object type:
| Boundary | Image |
| -------- | -------- |
diff --git a/ej2-react/diagram/bpmn-dataSource.md b/ej2-react/diagram/bpmn-dataSource.md
index 32ba2bfb8..4db02b64b 100644
--- a/ej2-react/diagram/bpmn-dataSource.md
+++ b/ej2-react/diagram/bpmn-dataSource.md
@@ -1,21 +1,29 @@
---
layout: post
-title: Bpmn DataSource in React Diagram component | Syncfusion®
-description: Learn here all about Bpmn shapes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: BPMN DataSource in React Diagram Component | Syncfusion®
+description: Learn how to create and configure BPMN data source shapes in Syncfusion® React Diagram Component for business process modeling.
control: Bpmn DataSource
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# BPMN Data source in React Diagram component
+# BPMN Data Source in React Diagram Component
-## Datasource
+## Overview
-Datasource is used to store or access data associated with a business process. To create a datasource, set the shape as **datasource**. The following code example illustrates how to create a datasource.
+BPMN data sources represent information that is required for or produced by business process activities. Data sources are essential elements in business process modeling that indicate where data comes from, how it flows through the process, and where it is stored or accessed.
+
+## Creating a Data Source
+
+To create a BPMN data source shape in the React Diagram component, set the shape type as **BpmnShape** and specify the shape property as **DataSource**. Data sources are typically used to represent databases, files, or other data repositories that business processes interact with.

+### Basic Data Source Implementation
+
+The following code example demonstrates how to create a basic BPMN data source shape:
+
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
{% include code-snippet/diagram/bpmnShapes/es5Datasource-cs1/app/index.jsx %}
diff --git a/ej2-react/diagram/bpmn-events.md b/ej2-react/diagram/bpmn-events.md
index d20fb75e0..97289307f 100644
--- a/ej2-react/diagram/bpmn-events.md
+++ b/ej2-react/diagram/bpmn-events.md
@@ -1,28 +1,29 @@
---
layout: post
-title: Bpmn Events in React Diagram component | Syncfusion®
-description: Learn here all about Bpmn shapes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: BPMN Events in React Diagram Component | Syncfusion®
+description: Learn about BPMN event shapes including start, intermediate, and end events with triggers in Syncfusion® React Diagram Component.
control: Bpmn Events
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# BPMN Event in React Diagram component
+# BPMN Event in React Diagram Component
-## Event
+## Overview
-An [`event`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnEvent) is a common BPMN process model element that represents something that happens during a business process and is notated with a circle. The type of events are as follows:
+An [`event`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnEvent) is a common BPMN process model element that is notated with a circle. Events can occur at the beginning, middle, or end of a process flow.
- * Start
- * Intermediate
- * NonInterruptingStart
- * NonInterruptingIntermediate
- * ThrowingIntermediate
- * End
-
-The [`event`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnEvent#event-bpmnevents) property of the node allows you to define the type of the event. The default value of the event is **start**. The following code example illustrates how to create a BPMN event.
+The types of events are as follows:
+* Start
+* Intermediate
+* NonInterruptingStart
+* NonInterruptingIntermediate
+* ThrowingIntermediate
+* End
+
+The `event`property of the node allows you to define the type of the event. The default value of the event is **start**. The following code example illustrates how to create a BPMN event.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -35,7 +36,9 @@ The [`event`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnEve
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5Event-cs1" %}
-Event triggers are notated as icons inside the circle and they represent the specific details of the process. The [`trigger`](https://helpej2.syncfusion.com/react/documentation/api/diagram/bpmnEvent/#trigger) property of the node allows you to set the type of trigger and by default, it is set as **none**. The following table illustrates the type of event triggers.
+## BPMN Event Trigger
+
+Event triggers are notated as icons inside the circle and represent the specific circumstances that cause the event to occur. The [`trigger`](https://helpej2.syncfusion.com/react/documentation/api/diagram/bpmnEvent/#trigger) property of the node allows you to set the type of trigger and by default, it is set as **none**. The following table illustrates the types of event triggers available for each event type.
| Triggers | Start | Non-Interrupting Start | Intermediate | Non-Interrupting Intermediate | Throwing Intermediate | End |
| -------- | -------- | -------- | -------- | -------- | -------- | -------- |
diff --git a/ej2-react/diagram/bpmn-expandedSubProcess.md b/ej2-react/diagram/bpmn-expandedSubProcess.md
index 9ad771388..54bf4a1bc 100644
--- a/ej2-react/diagram/bpmn-expandedSubProcess.md
+++ b/ej2-react/diagram/bpmn-expandedSubProcess.md
@@ -1,20 +1,24 @@
---
layout: post
-title: Bpmn Expanded subProcess in React Diagram component | Syncfusion®
-description: Learn here all about Bpmn shapes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: BPMN Expanded SubProcess in React Diagram component | Syncfusion®
+description: Learn how to create and manage BPMN expanded subprocess shapes with child processes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2.
control: Bpmn Expanded subProcess
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
+# BPMN Expanded SubProcess
-## Expanded SubProcess
-An expanded subProcess can contain certain child processess within it.
+## Overview
-### Create BPMN Expanded subProcess
+An expanded subprocess is a BPMN shape that represents a complex process containing multiple child processes within it. Unlike collapsed subprocesses, expanded subprocesses display their internal structure and allow users to view and interact with the child processes directly. This makes them ideal for detailed process modeling where visibility into subprocess components is essential.
-To create expanded subProcess, set shape as [`activity`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnActivityModel/) and [`collapsed`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcessModel/#collapsed) as false. Enable [`AllowDrop`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeConstraints/) constraint for node to allow child to drop inside the expanded subProcess.
+The expanded subprocess automatically adjusts its size to accommodate child elements and provides a container-like behavior for organizing related BPMN activities.
+
+### Create BPMN Expanded SubProcess
+
+To create an expanded subprocess, configure the shape as[`activity`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnActivityModel/) and [`collapsed`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcessModel/#collapsed) to false. Enable the [`AllowDrop`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeConstraints/) constraint to allow child nodes to be dropped inside the expanded subprocess container.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -27,11 +31,11 @@ To create expanded subProcess, set shape as [`activity`](https://ej2.syncfusion.
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5expand-cs1" %}
-### Add BPMN nodes into ExpandedSubProcess
+### Add BPMN Nodes into Expanded SubProcess
-[`Processes`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcessModel/#processes) is an array collection that defines the children values for BPMN subprocess.
+The [`Processes`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnSubProcessModel/#processes)property is an array collection that defines the child node values for the BPMN subprocess. This allows you to programmatically specify which BPMN elements should be contained within the expanded subprocess during initialization.
-Please refer the following code example.
+The following code example demonstrates how to define child processes within an expanded subprocess:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -44,19 +48,19 @@ Please refer the following code example.
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5expand-cs2" %}
-
-### Add BPMN nodes into ExpandedSubProcess at runtime
+### Add BPMN Nodes into Expanded SubProcess at Runtime
-Drag and drop the BPMN nodes to the BPMN ExpandedSubProcess.
-While resizing or dragging the child element, if the child element bounds are within the ExpandedSubProcess bounds, the ExpandedSubProcess size will be updated along with that.
+Users can drag and drop BPMN nodes directly onto the expanded subprocess container during runtime. The expanded subprocess automatically maintains proper containment by monitoring the bounds of child elements. When a child element is resized or repositioned within the subprocess boundaries, the expanded subprocess container dynamically adjusts its size to accommodate the changes.
-The following image shows how to add BPMNNode into the BPMN ExpandedSubProcess at runtime.
+This interactive behavior ensures that the subprocess container always properly encompasses all its child processes while maintaining visual clarity and proper BPMN structure.

-#### Add/remove Process Programmatically
+#### Add/Remove Process Programmatically
+
+The expanded subprocess supports dynamic process management through dedicated methods. Use the [`addProcess`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addprocess) method to add new child processes at runtime, and the [`removeProcess`](https://ej2.syncfusion.com/react/documentation/api/diagram/#removeprocess) method to remove existing processes. These methods provide programmatic control over subprocess content without requiring manual manipulation.
-The process for the expanded sub-process can be added at runtime using the [`addProcess`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addprocess) method and removed at runtime using the [`removeProcess`](https://ej2.syncfusion.com/react/documentation/api/diagram/#removeprocess) method. The following example shows how to add and remove a process at runtime.
+The following example demonstrates how to implement dynamic process addition and removal:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/bpmn-flows.md b/ej2-react/diagram/bpmn-flows.md
index 45acb89ad..60796b32f 100644
--- a/ej2-react/diagram/bpmn-flows.md
+++ b/ej2-react/diagram/bpmn-flows.md
@@ -1,30 +1,36 @@
---
layout: post
-title: Bpmn Flows in React Diagram component | Syncfusion®
-description: Learn here all about Bpmn shapes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: BPMN Flows in React Diagram Component | Syncfusion®
+description: Learn here all about Bpmn flows in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Bpmn Flows
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# BPMN flows in React Diagram component
+# BPMN flows in React Diagram Component
-[`BPMN Flows`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnFlow#BpmnFlow) are lines that connects BPMN flow objects.
+## Overview
-* Association
-* Sequence
-* Message
+[`BPMN Flows`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnFlow#BpmnFlow) are connecting lines that define relationships and information flow between BPMN elements in business process diagrams. These flows are essential for modeling how activities, events, and gateways interact within a process workflow.
-## Association flow
+BPMN flows are categorized into three main types:
-[`BPMN Association`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnFlow#association) flow is used to link flow objects with its corresponding text or artifact. An association is represented as a dotted graphical line with opened arrow. The types of association are as follows:
+* **Association** - Links flow objects with supporting text or artifacts.
+* **Sequence** - Shows the execution order of activities in a process.
+* **Message** - Represents communication between different process participants.
-* Directional
-* BiDirectional
-* Default
+## Association Flow
-The `association` property allows you to define the type of association. The following code example illustrates how to create an association.
+[`BPMN Association`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnFlow#association) flows connect BPMN flow objects with their corresponding text annotations or artifacts. Association flows are represented as dotted lines with open arrowheads and do not affect the sequence or execution of the process.
+
+The association flow supports three types:
+
+* **Directional** - Shows a one-way association from source to target.
+* **BiDirectional** - Indicates a two-way association between elements.
+* **Default** - A simple association without directional emphasis.
+
+The `association` property allows you to define the type of association. The following code example illustrates how to create an association flow:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -47,15 +53,17 @@ The following table demonstrates the visual representation of association flows.
N> The default value for the property `association` is **default**.
-## Sequence flow
+## Sequence Flow
-A [`sequence`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnFlow#sequence) flow shows the order in which the activities are performed in a BPMN process and is represented by a solid graphical line. The types of sequence are as follows:
+A [`Sequence`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnFlow#sequence) flow defines the execution order of activities, events, and gateways within a BPMN process. Sequence flows are represented by solid lines with closed arrowheads and control the flow of the process from one element to the next.
-* Normal
-* Conditional
-* Default
+The sequence flow supports three types:
-The sequence property allows you to define the type of sequence. The following code example illustrates how to create a sequence flow.
+* **Normal** - Standard flow path without special conditions.
+* **Conditional** - Flow that occurs only when specific conditions are met.
+* **Default** - Alternative flow path when conditional flows are not satisfied.
+
+The `sequence` property allows you to define the type of sequence flow. The following code example illustrates how to create a sequence flow:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -68,7 +76,7 @@ The sequence property allows you to define the type of sequence. The following c
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5Sequence-cs1" %}
-The following table contains various representation of sequence flows.
+The following table contains various representations of sequence flows:
| Sequence | Image |
| -------- | -------- |
@@ -76,17 +84,19 @@ The following table contains various representation of sequence flows.
| Conditional |  |
| Normal |  |
->Note: The default value for the property `sequence` is **normal**.
+N> The default value for the property `sequence` is **normal**.
+
+## Message Flow
-## Message flow
+A [`Message`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnFlow#message) flow represents the exchange of messages between different participants or pools in a BPMN process. Message flows are depicted as dashed lines and show communication that crosses organizational boundaries.
-A [`message`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnFlow#message) flow shows the flow of messages between two participants and is represented by dashed line. The types of message are as follows:
+The message flow supports three types:
-* InitiatingMessage
-* NonInitiatingMessage
-* Default
+* **InitiatingMessage** - Message that starts a process or triggers an activity.
+* **NonInitiatingMessage** - Message that provides information but does not start a process.
+* **Default** - Standard message flow without special initiation properties.
-The message property allows you to define the type of message. The following code example illustrates how to define a message flow.
+The `message` property allows you to define the type of message flow. The following code example illustrates how to define a message flow:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -99,7 +109,7 @@ The message property allows you to define the type of message. The following cod
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5Message-cs1" %}
-The following table contains various representation of message flows.
+The following table contains various representations of message flows:
| Message | Image |
| -------- | -------- |
diff --git a/ej2-react/diagram/bpmn-gateway.md b/ej2-react/diagram/bpmn-gateway.md
index 077644273..5aacb31d9 100644
--- a/ej2-react/diagram/bpmn-gateway.md
+++ b/ej2-react/diagram/bpmn-gateway.md
@@ -1,17 +1,23 @@
---
layout: post
-title: Bpmn Gateway in React Diagram component | Syncfusion®
-description: Learn here all about Bpmn shapes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: BPMN Gateway in React Diagram Component | Syncfusion®
+description: Learn how to create and configure BPMN gateways in Syncfusion React Diagram Component to control process flows with various gateway types.
control: Bpmn Gateway
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# BPMN Gateway in React Diagram component
+# BPMN Gateway in React Diagram Component
+
+## Overview
+
+BPMN (Business Process Model and Notation) gateways are crucial elements that control the flow of processes in business workflow diagrams. Gateways determine how process flows diverge or converge based on specific conditions, making them essential for modeling complex business logic and decision points.
## Gateway
-Gateway is used to control the flow of a process and it is represented as a diamond shape. To create a gateway, the shape property of the node should be set as [`gateway`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnGateways) and the gateway property can be set with any of the appropriate gateways. The following code example illustrates how to create a BPMN Gateway.
+A gateway is represented as a diamond shape and serves as a decision point that controls the sequence flow within a process. Gateways can split a single incoming flow into multiple outgoing flows or merge multiple incoming flows into a single outgoing flow.
+
+To create a gateway in the React Diagram component, set the shape property of the node to "gateway" and configure the [`gateway`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnGateways) property with the appropriate gateway type. The following code example demonstrates how to create a basic BPMN gateway.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -26,8 +32,9 @@ Gateway is used to control the flow of a process and it is represented as a diam
N> By default, the `gateway` will be set as **none**.
-There are several types of gateways as tabulated:
+## Gateway Types
+The React Diagram component supports various gateway types, each serving specific process control requirements:
| Shape | Image |
| -------- | -------- |
| Exclusive |  |
diff --git a/ej2-react/diagram/bpmn-groups.md b/ej2-react/diagram/bpmn-groups.md
index 540df8d10..d6560048f 100644
--- a/ej2-react/diagram/bpmn-groups.md
+++ b/ej2-react/diagram/bpmn-groups.md
@@ -1,17 +1,22 @@
---
layout: post
-title: Bpmn Group in React Diagram component | Syncfusion®
-description: Learn here all about Bpmn shapes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: BPMN Group in React Diagram Component | Syncfusion®
+description: Learn how to create and customize BPMN group shapes for organizing related elements in Syncfusion® React Diagram Component.
control: Bpmn Group
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
+# BPMN Group in React Diagram Component
-## Group
+## Overview
-A group is used to frame a part of the diagram, shows that elements included in it are logically belong together and does not have any other semantics other than organizing elements. To create a group, the shape property of the node should be set as **group**. The following code example illustrates how to create a BPMN group.
+A BPMN group is a visual mechanism used to organize and frame related elements within a business process diagram. Groups indicate that the enclosed elements logically belong together while providing no additional semantic meaning beyond visual organization. Unlike other BPMN constructs, groups serve purely as organizational containers to improve diagram readability and structure.
+
+## Creating a BPMN Group
+
+To create a BPMN group, set the [`shape`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnShapes/) property of the node to **group**. The group appears as a rounded rectangle with dashed borders that encompasses the grouped elements.

diff --git a/ej2-react/diagram/bpmn-shapes.md b/ej2-react/diagram/bpmn-shapes.md
index a5640f022..0e4a212de 100644
--- a/ej2-react/diagram/bpmn-shapes.md
+++ b/ej2-react/diagram/bpmn-shapes.md
@@ -1,18 +1,20 @@
---
layout: post
-title: Bpmn shapes in React Diagram component | Syncfusion®
-description: Learn here all about Bpmn shapes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: BPMN shapes in React Diagram Component | Syncfusion®
+description: Learn to create and configure BPMN shapes in the Syncfusion React Diagram Component for modeling business processes with events, gateways, and tasks.
control: Bpmn shapes
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Bpmn shapes in React Diagram component
+# BPMN Shapes in React Diagram Component
-BPMN shapes are used to represent the internal business procedure in a graphical notation and enable you to communicate the procedures in a standard manner. To create a BPMN shape, in the node property shape, type should be set as “bpmn” and its shape should be set as any one of the built-in shapes. The following code example illustrates how to create a simple business process.
+BPMN (Business Process Model and Notation) shapes are standardized graphical elements used to represent business processes in a visual workflow. These shapes enable teams to communicate business procedures clearly and consistently across organizations. The React Diagram component provides comprehensive support for creating BPMN diagrams with all standard shape types.
-N> If you want to use BPMN shapes in diagram, you need to inject BpmnDiagrams in the diagram.
+To create a BPMN shape, set the node's shape type property to **BPMN** and specify the shape property as one of the available built-in shapes. Each BPMN shape serves a specific purpose in modeling business processes, from representing events and activities to showing data flow and decision points.
+
+> **Important**: To use BPMN shapes in the diagram, inject the BpmnDiagrams module into the diagram component. This module provides the necessary functionality for rendering and managing BPMN-specific features.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -25,10 +27,11 @@ N> If you want to use BPMN shapes in diagram, you need to inject BpmnDiagrams in
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5bpmn-cs1" %}
->Note : The default value for the property `shape` is “event”.
+>Note : The default value for the property `shape` is **event**.
-The list of BPMN shapes are as follows:
+## Available BPMN Shapes
+The react Diagram component supports the following standard BPMN shapes:
| Shape | Image |
| -------- | -------- |
| Event |  |
@@ -39,6 +42,26 @@ The list of BPMN shapes are as follows:
| DataObject |  |
| Group |  |
-The BPMN shapes and its types are explained as follows.
+## BPMN Shape Types and Configuration
+
+Each BPMN shape category includes multiple subtypes that can be configured to represent specific business process elements. The shapes can be customized with various properties to match specific modeling requirements and visual preferences.
+
+### Events
+Events represent specific occurrences that trigger, interrupt, or conclude process flows. They include start events, intermediate events, and end events, each serving different purposes in process modeling.
+
+### Gateways
+Gateways control the sequence flow within a process by determining how paths converge and diverge. They include exclusive, inclusive, parallel, and complex gateway types for different decision-making scenarios.
+
+### Tasks
+Tasks represent atomic work activities that cannot be broken down further. They can be configured as user tasks, service tasks, manual tasks, or other specialized task types depending on the nature of the work.
+
+### Data Elements
+Data objects and data sources represent information that flows through or supports the business process, helping to model how data is created, used, and stored throughout the workflow.
+
+## Best Practices
-
+- Use consistent shape sizing and positioning to maintain visual clarity.
+- Apply appropriate shape subtypes to accurately represent business logic.
+- Ensure proper sequence flow connections between shapes.
+- Group related elements using the Group shape for better organization.
+- Follow BPMN 2.0 standards for shape usage and process flow modeling.
\ No newline at end of file
diff --git a/ej2-react/diagram/bpmn-textAnnotation.md b/ej2-react/diagram/bpmn-textAnnotation.md
index a8923b39c..8562319b7 100644
--- a/ej2-react/diagram/bpmn-textAnnotation.md
+++ b/ej2-react/diagram/bpmn-textAnnotation.md
@@ -1,32 +1,30 @@
---
layout: post
-title: Bpmn Text annotation in React Diagram component | Syncfusion®
-description: Learn here all about Bpmn shapes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
-control: Bpmn Text annotation
+title: BPMN Text Annotation in React Diagram Component | Syncfusion®
+description: Learn how to create, configure, and manage BPMN text annotations in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
+control: Bpmn Text annotation
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# BPMN text annotation in React Diagram component
+# BPMN Text Annotation in React Diagram Component
-## Text annotation
+## Overview
-* A BPMN object can be associated with a text annotation which does not affect the flow but gives details about objects within a flow.
+A BPMN object can be associated with a text annotation that provides additional details about objects within a flow without affecting the actual process flow. Text annotations serve as documentation elements that help explain or clarify specific aspects of the BPMN diagram.
-* A TextAnnotation points to or references another BPMN shape, which we call the `textAnnotationTarget` of the textAnnotation. When a target shape is moved or deleted, any TextAnnotations attached to the shape will be moved or deleted too. Thus, the TextAnnotations remain with their target shapes though you can reposition the TextAnnotation to any offset from its target. The `textAnnotationTarget` property of the BpmnTextAnnotation is used to connect an annotation element to the BPMN Node.
+A TextAnnotation points to or references another BPMN shape through the [`textAnnotationTarget`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnTextAnnotation/#textannotationtarget) property. When the target shape is moved or deleted, any TextAnnotations attached to the shape will automatically move or be deleted as well. This ensures that TextAnnotations remain associated with their target shapes, though the TextAnnotation can be repositioned to any offset from its target.
-* The annotation element can be switched from a BPMN node to another BPMN node simply by dragging the source end of the annotation connector into the other BPMN node.
+The annotation element can be switched from one BPMN node to another by simply dragging the source end of the annotation connector to the desired BPMN node. By default, the TextAnnotation shape includes a connection to its target.
* By default, the TextAnnotation shape has a connection.
-* The `textAnnotationDirection` property is used to set the shape direction of the text annotation.
+The [`textAnnotationDirection`](https://helpej2.syncfusion.com/react/documentation/api/diagram/bpmnTextAnnotation/#textannotationdirection) property controls the shape direction of the text annotation. By default, this property is set to **Auto**, which automatically determines the optimal direction based on the target's position.
-* By default, the `textAnnotationDirection` is set to a Auto.
+To set the size for text annotation, use the [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#height) properties of the node.
-* To set the size for text annotation, use the `width` and `height` properties of the node.
-
-* The `offsetX` and `offsetY` properties are used to set the distance between the BPMN node and the TextAnnotation.
+The [`offsetX`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnTextAnnotation/#offsetx) and [`offsetY`](https://ej2.syncfusion.com/react/documentation/api/diagram/bpmnTextAnnotation/#offsety) properties determine the distance between the BPMN node and the TextAnnotation.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -39,9 +37,9 @@ domainurl: ##DomainURL##
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5Text-cs1" %}
-### Text annotation in palette.
+### Text Annotation in Palette.
-Text annotation node can be rendered in symbol palette like other bpmn shapes. The following example shows how to render Bpmn text annotation node in symbol palette.
+Text annotation nodes can be rendered in the symbol palette alongside other BPMN shapes. The following example demonstrates how to render BPMN text annotation nodes in the symbol palette.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -54,18 +52,17 @@ Text annotation node can be rendered in symbol palette like other bpmn shapes. T
{% previewsample "page.domainurl/code-snippet/diagram/bpmnShapes/es5Text1-cs1" %}
-### Connect the TextAnnotation to BPMN node
+### Connect the TextAnnotation to BPMN Node
-Drag and drop any bpmn shapes from the palette to diagram and connect the BPMN Node and textAnnotation.
+Users can drag and drop any BPMN shapes from the palette to the diagram and establish connections between BPMN nodes and text annotations through interactive manipulation.
-The following image shows how to drag a symbol from the palette and connect the textAnnotation to the BPMNNode with interaction.
+The following image demonstrates how to drag a symbol from the palette and connect the text annotation to a BPMN node using interaction.

-### Text annotation direction
-
-There are several types of Text annotation directions as follows:
+### Text Annotation Direction
+The text annotation supports several directional orientations to optimize the visual layout of the diagram:
| Text annotation direction | Image |
| -------- | -------- |
| Auto |  |
@@ -74,10 +71,10 @@ There are several types of Text annotation directions as follows:
| Top |  |
| Bottom |  |
-### Add text annotation at runtime
-
-Text annotations can be added dynamically using either the [`addTextAnnotation`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addtextannotation) method or the [`add`](https://ej2.syncfusion.com/react/documentation/api/diagram/#add) method of the diagram. The following example shows how to use these methods to add a text annotation node.
+### Add Text Annotation at Runtime
+Text annotations can be added dynamically using either the [`addTextAnnotation`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addtextannotation) method or the [`add`](https://ej2.syncfusion.com/react/documentation/api/diagram/#add) method of the diagram. The following example shows how to use these methods to add a text annotation node programmatically.
+
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
{% include code-snippet/diagram/bpmnShapes/es5Text2-cs1/app/index.jsx %}
diff --git a/ej2-react/diagram/commands.md b/ej2-react/diagram/commands.md
index e4a9d7a8d..ed591d1ce 100644
--- a/ej2-react/diagram/commands.md
+++ b/ej2-react/diagram/commands.md
@@ -1,21 +1,21 @@
---
layout: post
-title: Commands in React Diagram component | Syncfusion®
-description: Learn here all about Commands in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Commands in React Diagram Component | Syncfusion®
+description: Learn here all about Commands in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Commands
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Commands in React Diagram component
+# Commands in React Diagram Component
The commands in diagram control are used to perform various interactions within the diagram when called. Several commands are available in the diagram, as follows:
* Alignment commands
-* Spacing commands
+* Distribute commands
* Sizing commands
* Clipboard commands
* Grouping commands
@@ -25,9 +25,9 @@ The commands in diagram control are used to perform various interactions within
* FitToPage commands
* Undo/Redo commands
-## Align commands
+## Alignment Commands
- The alignment commands enable you to align the selected or defined objects such as nodes and connectors with respect to the selection boundary. Refer to [`align`](https://ej2.syncfusion.com/react/documentation/api/diagram#align) commands which shows how to use align methods in the diagram.
+The alignment command enables you to align selected or defined objects, such as nodes and connectors, with respect to the selection boundary or the first selected object. The [`align`](https://ej2.syncfusion.com/react/documentation/api/diagram#align) method parameters are explained below.
### Alignment Options
@@ -46,17 +46,17 @@ The [`Alignment Options`](https://ej2.syncfusion.com/react/documentation/api/dia
### Objects
-Defines the objects to be aligned. This is an optional parameter. By default, all the nodes and connectors in the selected region of the diagram gets aligned.
+Defines the objects to be aligned. This is an optional parameter. By default, all the nodes and connectors in the selected region of the diagram get aligned.
### Alignment Mode
-[`Alignment Mode`](https://ej2.syncfusion.com/react/documentation/api/diagram/alignmentMode/) defines the specific mode, with respect to which the objects to be aligned. This is an optional parameter. The default alignment mode is `Object`. The accepted values of the argument "alignment mode" are as follows.
+[`Alignment Mode`](https://ej2.syncfusion.com/react/documentation/api/diagram/alignmentMode/) defines the specific mode with respect to which the objects are aligned. This is an optional parameter. The default alignment mode is **Object**. The accepted values of the argument "alignment mode" are as follows.
-The below table shows the alignment as `Left` for different alignment modes.
+The table below shows the alignment as **Left** for different alignment modes.
|Nodes before alignment|Alignment mode|Description|Output image|
|----|----|----|----|
-||Object (Default)|Aligns the objects based on the bounds of first object in the selected list.||
+||Object (Default)|Aligns the objects based on the bounds of the first object in the selected list.||
||Selector|Aligns the objects based on the selection boundary.||
@@ -75,13 +75,13 @@ The following code example illustrates how to align all the selected objects at

-## Distribute commands
+## Distribute Commands
-The [`distribute`](https://ej2.syncfusion.com/react/documentation/api/diagram#distribute)method enable you to place the selected objects on the page at equal intervals from each other. The selected objects are equally spaced within the selection boundary. The [`distribute`](https://ej2.syncfusion.com/react/documentation/api/diagram#distribute) method parameters are explained below.
+The [`distribute`](https://ej2.syncfusion.com/react/documentation/api/diagram#distribute)method enable you to place the selected objects on the page at equal intervals from each other. The selected objects are equally spaced within the selection boundary. The `distribute` method parameters are explained below.
-### Distribute options
+### Distribute Options
-The factor to distribute the shapes [`DistributeOptions`](https://ej2.syncfusion.com/react/documentation/api/diagram/distributeOptions#DistributeOptions) are listed as follows:
+The factors for distributing shapes using [`DistributeOptions`](https://ej2.syncfusion.com/react/documentation/api/diagram/distributeOptions#DistributeOptions) are listed as follows:
|Distribute option| Description|
|----|----|
@@ -96,9 +96,9 @@ The factor to distribute the shapes [`DistributeOptions`](https://ej2.syncfusion
### Objects
-Defines the objects to be distributed. This is an optional parameter. By default, all the nodes and connectors in the selected region of the diagram gets distributed.
+Defines the objects to be distributed. This is an optional parameter. By default, all the nodes and connectors in the selected region of the diagram get distributed.
-The following code example illustrates how the nodes are distributed using the `RightToLeft` option.
+The following code example illustrates how the nodes are distributed using the **RightToLeft** option.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -113,11 +113,11 @@ The following code example illustrates how the nodes are distributed using the `

-## Sizing commands
+## Sizing Commands
-The [`sameSize`](https://ej2.syncfusion.com/react/documentation/api/diagram/#samesize) command enables you to size all selected nodes to match the size of the first selected object or the first node in the objects collection you provide as the second parameter. The parameters for the [`sameSize`](https://ej2.syncfusion.com/react/documentation/api/diagram/#samesize) method are explained below.
+The [`sameSize`](https://ej2.syncfusion.com/react/documentation/api/diagram/#samesize) command enables you to size all selected nodes to match the size of the first selected object or the first node in the objects collection you provide as the second parameter. The parameters for the `sameSize` method are explained below.
-### Sizing options
+### Sizing Options
[`SizingOptions`](https://ej2.syncfusion.com/react/documentation/api/diagram/sizingOptions) include:
@@ -146,18 +146,17 @@ The following code example illustrates how to execute the size commands.

-## Clipboard commands
+## Clipboard Commands
-
-Clipboard commands are used to cut, copy, or paste selected elements in the diagram using the [`cut`](https://ej2.syncfusion.com/react/documentation/api/diagram#cut), [`copy`](https://ej2.syncfusion.com/react/documentation/api/diagram#copy), [`paste`](https://ej2.syncfusion.com/react/documentation/api/diagram#paste) methods. You can also use keyboard shortcuts for these actions. For detailed information on using these methods refer the below table.
+Clipboard commands are used to cut, copy, or paste selected elements in the diagram using the [`cut`](https://ej2.syncfusion.com/react/documentation/api/diagram#cut), [`copy`](https://ej2.syncfusion.com/react/documentation/api/diagram#copy), and [`paste`](https://ej2.syncfusion.com/react/documentation/api/diagram#paste) methods. You can also use keyboard shortcuts for these actions. For detailed information on using these methods refer to the table below.
| Command (Shortcut key) | Description |
|---------|-------------|
-| `Cut` (CTRL+X) | Removes the selected elements from the diagram and places them onto the diagram’s clipboard. This operation is performed using the [`cut`](https://ej2.syncfusion.com/react/documentation/api/diagram#cut) method. |
-| `Copy`(CTRL+C) | Duplicates the selected elements and places them onto the diagram’s clipboard without removing them from their original location. Use the [`copy`](https://ej2.syncfusion.com/react/documentation/api/diagram#copy) method for this operation. |
-| `Paste`(CTRL+V) | Inserts the elements stored on the diagram’s clipboard (nodes and connectors) into the diagram. This can be done using the [`paste`](https://ej2.syncfusion.com/react/documentation/api/diagram#paste) method. |
+| `Cut` (CTRL+X) | Removes the selected elements from the diagram and places them onto the diagram’s clipboard. This operation is performed using the `cut` method. |
+| `Copy`(CTRL+C) | Duplicates the selected elements and places them onto the diagram’s clipboard without removing them from their original location. Use the `copy` method for this operation. |
+| `Paste`(CTRL+V) | Inserts the elements stored on the diagram’s clipboard (nodes and connectors) into the diagram. This can be done using the `paste` method. |
-The [`paste`](https://ej2.syncfusion.com/react/documentation/api/diagram#paste) method optionally accepts a collection of nodes or connectors to be added to the diagram.
+The `paste` method optionally accepts a collection of nodes or connectors to be added to the diagram.
The following code illustrates how to execute the clipboard commands.
@@ -172,14 +171,14 @@ The following code illustrates how to execute the clipboard commands.
{% previewsample "page.domainurl/code-snippet/diagram/commands/es5clipboard-cs1" %}
-## Grouping commands
+## Grouping Commands
-Grouping Commands are used to group or ungroup selected elements in the diagram. Grouping commands help in managing and organizing multiple elements by combining them into a single group or separating them into individual elements. You can also use keyboard shortcuts for these actions. The following table provides more details on these commands:
+Grouping commands are used to group or ungroup selected elements in the diagram. Grouping commands help in managing and organizing multiple elements by combining them into a single group or separating them into individual elements. You can also use keyboard shortcuts for these actions. The following table provides more details on these commands:
| Commands (Shortcut key) | Description|
|----|----|
| [`Group`](https://ej2.syncfusion.com/react/documentation/api/diagram#group) (CTRL+G) | Combines the selected nodes and connectors into a single group, allowing you to move, resize, or apply other operations to all grouped elements as a unit. |
-| [`Ungroup`](https://ej2.syncfusion.com/react/documentation/api/diagram#ungroup) (CTRL+Shift+U) | Splits a previously grouped set of nodes and connectors into individual elements, enabling you to modify or manipulate them separately. |
+| [`Ungroup`](https://ej2.syncfusion.com/react/documentation/api/diagram#ungroup) (CTRL+Shift+U) | Splits a previously grouped set of nodes and connectors into individual elements, enabling you to modify or manipulate them separately. |
The following code examples demonstrate how to use the grouping commands in diagram:
@@ -194,9 +193,9 @@ The following code examples demonstrate how to use the grouping commands in diag
{% previewsample "page.domainurl/code-snippet/diagram/commands/es5grouping-cs1" %}
-## Rotate commands
+## Rotate Commands
-The [`rotate`](https://ej2.syncfusion.com/react/documentation/api/diagram/#rotate) commands in the diagram allow users to rotate selected elements by specified angles. These commands are useful for adjusting the rotate angle of nodes or shapes within the diagram.
+The [`rotate`](https://ej2.syncfusion.com/react/documentation/api/diagram/#rotate) commands in the diagram allow users to rotate selected elements by specified angles. These commands are useful for adjusting the rotation angle of nodes or shapes within the diagram.
| Parameter | Type | Description |
|----------|-------|-------------|
@@ -205,7 +204,7 @@ The [`rotate`](https://ej2.syncfusion.com/react/documentation/api/diagram/#rotat
| pivot (optional) | PointModel| The reference point with respect to which the objects will be rotated. |
| rotateUsingHandle (optional) | boolean | Whether to rotate using the handle. |
-You can also use CTRL+R to rotate clockwise and CTRL+L to rotate anti-clockwise. The following example shows how to rotate nodes in clockwise and anti-clockwise direction.
+You can also use CTRL+R to rotate clockwise and CTRL+L to rotate anti-clockwise. The following example shows how to rotate nodes in clockwise and anti-clockwise directions.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -218,11 +217,11 @@ You can also use CTRL+R to rotate clockwise and CTRL+L to rotate anti-clockwise.
{% previewsample "page.domainurl/code-snippet/diagram/commands/rotate-cs1" %}
-## Z-Order command
+## Z-Order Command
-**Z-Order commands** enable you to visually arrange the selected objects such as nodes and connectors on the page.
+**Z-Order Commands** enable you to visually arrange the selected objects such as nodes and connectors on the diagram page.
-### Bring To Front command
+### Bring To Front Command
The [`bringToFront`](https://ej2.syncfusion.com/react/documentation/api/diagram/#bringtofront)command moves the selected element to the front, placing it above all other elements in the diagram. The following code illustrates how to use the `bringToFront` command.
@@ -237,9 +236,9 @@ The [`bringToFront`](https://ej2.syncfusion.com/react/documentation/api/diagram/
{% previewsample "page.domainurl/code-snippet/diagram/commands/es5bringfront-cs1" %}
-### Send To Back command
+### Send To Back Command
-The [`sendToBack`](https://ej2.syncfusion.com/react/documentation/api/diagram/#sendtoback) command moves the selected element to the back, placing it behind all other elements in the diagram. The following code illustrates how to use the `sendToBack` command.
+The [`sendToBack`](https://ej2.syncfusion.com/react/documentation/api/diagram/#sendtoback) command visually moves the selected element behind all the other overlapped elements. The following code illustrates how to execute the `sendToBack` command.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -252,9 +251,9 @@ The [`sendToBack`](https://ej2.syncfusion.com/react/documentation/api/diagram/#s
{% previewsample "page.domainurl/code-snippet/diagram/commands/es5sendback-cs1" %}
-### Move Forward command
+### Move Forward Command
-The [`moveForward`](https://ej2.syncfusion.com/react/documentation/api/diagram/#moveforward) command moves the selected element over the nearest overlapping element. The following code illustrates how to execute the `moveForward` command.
+The [`moveForward`](https://ej2.syncfusion.com/react/documentation/api/diagram/#moveforward) command visually moves the selected element over the nearest overlapping element. The following code illustrates how to execute the `moveForward` command.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -267,7 +266,7 @@ The [`moveForward`](https://ej2.syncfusion.com/react/documentation/api/diagram/#
{% previewsample "page.domainurl/code-snippet/diagram/commands/es5moveforward-cs1" %}
-### sendBackward command
+### Send Backward Command
The [`sendBackward`](https://ej2.syncfusion.com/react/documentation/api/diagram#sendbackward) command visually moves the selected element behind the underlying element. The following code illustrates how to execute the `sendBackward` command.
@@ -325,9 +324,9 @@ root.render();
```
For more information about zoom refer to the [zoom](./scroll-settings/#update-zoom-at-runtime)
-## Nudge command
+## Nudge Command
-The [`nudge`](https://ej2.syncfusion.com/react/documentation/api/diagram#nudge) commands move the selected elements towards up, down, left, or right by 1 pixel.The parameters of [`nudge`](https://ej2.syncfusion.com/react/documentation/api/diagram#nudge) method is explained below.
+The [`nudge`](https://ej2.syncfusion.com/react/documentation/api/diagram#nudge) commands move the selected elements towards up, down, left, or right by 1 pixel.The parameters of the `nudge` method is explained below.
| Parameter | Type | Description |
|--------------|-----------|-----------|
@@ -356,13 +355,13 @@ The following code illustrates how to execute the nudge command.
{% previewsample "page.domainurl/code-snippet/diagram/commands/nudge-cs1" %}
-### Nudge by using arrow keys
+### Nudge by Using Arrow Keys
-The arrow keys can be used to move the selected elements towards up, down, left, or right direction by 1 pixel.
+The arrow keys can be used to move the selected elements up, down, left, or right by 1 pixel.

-Nudge commands are particularly useful for accurate placement of elements.
+Nudge commands are particularly useful for accurate placement of elements.
N> The position change event will not trigger when using keyboard keys to move a node or connector.
@@ -370,9 +369,9 @@ N> The position change event will not trigger when using keyboard keys to move a
The [`bringIntoView`](https://ej2.syncfusion.com/react/documentation/api/diagram#bringintoview) command brings the specified rectangular region into the viewport of the diagram, ensuring that it is visible within the current view.
-The [`bringIntoView`](https://ej2.syncfusion.com/react/documentation/api/diagram#bringintoview) method takes a single parameter, an object that defines the rectangular region to bring into view. This object should include properties such as x, y, width, and height to specify the exact region to be made visible.
+The `bringIntoView` method takes a single parameter, an object that defines the rectangular region to bring into view. This object should include properties such as x, y, width, and height to specify the exact region to be made visible.
-The following code illustrates how to execute the bringIntoView command:
+The following code illustrates how to execute the `bringIntoView` command.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -389,9 +388,9 @@ The following code illustrates how to execute the bringIntoView command:
The [`bringToCenter`](https://ej2.syncfusion.com/react/documentation/api/diagram#bringtocenter) command centers the specified rectangular region of the diagram content within the viewport.
-The [`bringToCenter`](https://ej2.syncfusion.com/react/documentation/api/diagram#bringtocenter) method takes a single parameter, an object that defines the rectangular region to be centered. This object should include properties such as x, y, width, and height to specify the exact region to be brought to the center.
+The `bringToCenter` method takes a single parameter, an object that defines the rectangular region to be centered. This object should include properties such as x, y, width, and height to specify the exact region to be brought to the center.
-The following code illustrates how to execute the bringToCenter command.
+The following code illustrates how to execute the `bringToCenter` command.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -406,17 +405,17 @@ The following code illustrates how to execute the bringToCenter command.
## FitToPage
-The [`fitToPage`](https://ej2.syncfusion.com/react/documentation/api/diagram#fittopage)command adjusts the diagram content to fit within the viewport, considering either width, height, or the entire content. The fitToPage method takes one parameter,[`fitOptions`](https://ej2.syncfusion.com/react/documentation/api/diagram/FitOptions/), which specifies the options for fitting the diagram to the page.
+The [`fitToPage`](https://ej2.syncfusion.com/react/documentation/api/diagram#fittopage)command helps to fit the diagram content into the view with respect to either width, height, or the entire content. The fitToPage method takes one parameter,[`fitOptions`](https://ej2.syncfusion.com/react/documentation/api/diagram/FitOptions/), which specifies the options for fitting the diagram to the page.
### FitOptions
-The [`mode`](https://ej2.syncfusion.com/react/documentation/api/diagram/fitModes#modes) parameter defines how the diagram should fit into the viewport—horizontally, vertically, or based on the entire bounds of the diagram.
+The [`mode`](https://ej2.syncfusion.com/react/documentation/api/diagram/fitModes#modes) parameter defines whether the diagram has to be horizontally/vertically fit into the viewport with respect to width, height, or entire bounds of the diagram.
-The [`region`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRegions#region)parameter specifies the region of the diagram that should be fit within viewport.
+The [`region`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRegions#region) parameter defines the region that has to be drawn as an image.
-The [`margin`](https://ej2.syncfusion.com/react/documentation/api/diagram/iFitOptions#margin) parameter sets the margin around the diagram content that should be included in the view.
+The [`margin`](https://ej2.syncfusion.com/react/documentation/api/diagram/iFitOptions#margin) parameter defines the region/bounds of the diagram content that is to be fit into the view.
-The [`canZoomIn`](https://ej2.syncfusion.com/react/documentation/api/diagram/iFitOptions#canZoomIn) parameter enables or disables zooming in to fit smaller content into a larger viewport.
+The [`canZoomIn`](https://ej2.syncfusion.com/react/documentation/api/diagram/iFitOptions#canZoomIn) parameter enables/disables zooming to fit the smaller content into a larger viewport.
The [`canZoomOut`](https://ej2.syncfusion.com/react/documentation/api/diagram/iFitOptions/#canzoomout) parameter enables or disables zooming out to fit larger content into a smaller viewport.
@@ -435,13 +434,13 @@ The following code illustrates how to execute `FitToPage` command.
{% previewsample "page.domainurl/code-snippet/diagram/commands/fitToPage-cs1" %}
-## Command manager
+## Command Manager
The Diagram provides support for mapping or binding command execution to specific key gestures. It includes built-in commands and allows for the definition of custom commands through the [`CommandManager`](https://ej2.syncfusion.com/react/documentation/api/diagram/commandManager#commandManager) Custom commands are executed when the specified key gesture is recognized.
-## Custom command
+## Custom Command
-To define a custom command, specify the following properties:
+To define a custom command, you need to specify the following properties:
* [`execute`](https://ej2.syncfusion.com/react/documentation/api/diagram/command#execute): A method to be executed when the command is triggered.
* [`canExecute`](https://ej2.syncfusion.com/react/documentation/api/diagram/command#canexecute): A method to define whether the command can be executed at the moment.
@@ -451,7 +450,7 @@ To define a custom command, specify the following properties:
To explore the properties of custom commands, refer to [`Commands`](https://ej2.syncfusion.com/react/documentation/api/diagram/command#commands).
-The following code example illustrates how to use the command manager to clone a node and change the fill color of a node while pressing `G` and `Shift+G` or `Alt+G`, respectively:
+The following code example illustrates how to use the command manager to clone a node and change the fill color of a node while pressing **G** and **Shift+G** or **Alt+G**, respectively:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -464,9 +463,9 @@ The following code example illustrates how to use the command manager to clone a
{% previewsample "page.domainurl/code-snippet/diagram/commands/customCommand-cs1" %}
-### Disable/Modify the existing command
+### Disable/Modify the Existing Command
-When any of the default commands are not desired, they can be disabled. Additionally, if you need to change the functionality of a specific command, it can be completely modified.
+When any one of the default commands is not desired, they can be disabled. To change the functionality of a specific command, the command can be completely modified.
The following code example illustrates how to disable the default cut and delete commands using CTRL+X and Delete keys, and how to modify the copy command to clone a node using CTRL+C:
@@ -481,9 +480,9 @@ The following code example illustrates how to disable the default cut and delete
{% previewsample "page.domainurl/code-snippet/diagram/commands/modifyCommand-cs1" %}
-## Undo-redo
+## Undo-Redo
-Undo/redo commands can be executed through shortcut keys. Shortcut key for undo is **`Ctrl+z`** and shortcut key for redo is **`Ctrl+y`**. For more information refer to the [`undo-redo`](./undo-redo)
+Undo/redo commands can be executed through shortcut keys. Shortcut key for undo is **Ctrl+z** and shortcut key for redo is **Ctrl+y**. For more information refer to the [`undo-redo`](./undo-redo)
## See Also
diff --git a/ej2-react/diagram/complex-layout.md b/ej2-react/diagram/complex-layout.md
index 99c249a1b..54849db9a 100644
--- a/ej2-react/diagram/complex-layout.md
+++ b/ej2-react/diagram/complex-layout.md
@@ -9,15 +9,14 @@ domainurl: ##DomainURL##
---
-# Complex hierarchical tree layout in React Diagram control
+# Complex Hierarchical Tree Layout in React Diagram Component
-Complex hierarchical tree layout arranges nodes in a tree-like structure, where the child node can have more than one parent. This layout is an extended version of the hierarchical tree layout. To create a complex hierarchical tree, the [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#type) property of layout should be set as `ComplexHierarchicalTree`.
+Complex hierarchical tree layout arranges nodes in a tree-like structure where child nodes can have multiple parent nodes, creating interconnected relationships beyond traditional single-parent hierarchies. This layout type is ideal for organizational charts with dotted-line relationships, project dependencies, or any structure where entities report to multiple authorities. This layout extends the standard hierarchical tree layout to support these complex relationships.
+To create a complex hierarchical tree, set the [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#type) property of layout to **ComplexHierarchicalTree**.
+## Complex Hierarchical Tree Layout with Nodes and Connectors
-## Complex hierarchical tree layout with nodes and connectors
-
-The following example demonstrates how to render a complex hierarchical tree layout using nodes and connectors. To achieve this, you need to define the nodes and connectors collections and assign them to the diagram. Additionally, you need to set the layout type to `ComplexHierarchicalTree`.
-
+This example demonstrates how to create a complex hierarchical tree layout by manually defining nodes and connectors. The layout automatically positions nodes based on their hierarchical relationships while handling multiple parent-child connections.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -31,10 +30,9 @@ The following example demonstrates how to render a complex hierarchical tree lay
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/complexhiertree-cs1" %}
-## Complex hierarchical tree layout with DataSource
-
-The following code example illustrates how to create a complex hierarchical tree with DataSource.
+## Complex Hierarchical Tree Layout with DataSource
+When working with large datasets, binding the layout to a data source provides better maintainability and dynamic content management. The following example shows how to create a complex hierarchical tree using a data source configuration.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -50,12 +48,12 @@ The following code example illustrates how to create a complex hierarchical tree

->Note: In Diagram Layouts, all root nodes will always render at the same level. This default behavior cannot be changed to render different trees at distinct levels.
+>Note: In Diagram layouts, all root nodes will always render at the same level. This default behavior cannot be changed to render different trees at distinct levels.
## Line Distribution
-Line distribution is used to arrange the connectors without overlapping in automatic layout. In some cases, the automatic layout connectors connecting to the nodes will be overlapped with one another. So user can decide whether the segment of each connector from a single parent node should be same point or different point. The [`connectionPointOrigin`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionPointOrigin/#connectionpointorigin) property of layout is used to enable or disable the line distribution in layout. By default ConnectionPointOrigin will be `SamePoint`.
+Line distribution prevents connector overlap by controlling how multiple connectors from a single parent node are positioned. Without line distribution, connectors may overlap and create visual confusion in complex layouts. The [`connectionPointOrigin`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionPointOrigin/#connectionpointorigin) property of layout is used to enable or disable the line distribution in layout. By default ConnectionPointOrigin will be **SamePoint**.
The following code example illustrates how to create a complex hierarchical tree with line distribution.
@@ -79,7 +77,10 @@ The following code example illustrates how to create a complex hierarchical tree
## Linear Arrangement
-Linear arrangement is used to linearly arrange the child nodes in layout, which means the parent node is placed in the center corresponding to its children. When line distribution is enabled, linear arrangement is also activated by default. The [`arrangement`](https://ej2.syncfusion.com/react/documentation/api/diagram/childarrangement/) property of layout is used to enable or disable the linear arrangement in layout. By default arrangement will be `Nonlinear`.
+Linear arrangement is used to linearly arrange the child nodes in layout, which means the parent node is placed in the center corresponding to its children. When line distribution is enabled, linear arrangement is also activated by default. The [`arrangement`](https://ej2.syncfusion.com/react/documentation/api/diagram/childarrangement/) property provides control over this feature:
+
+- **Nonlinear (default)**: Child nodes are arranged based on available space
+- **Linear**: Child nodes are arranged in a straight line with the parent centered. By default arrangement will be **Nonlinear**.
>Note: If you want to use linear arrangement in diagram layout, you need to inject LineDistribution module in the diagram. Linear arrangement is applicable only for complex hierarchical tree layout.
@@ -99,11 +100,11 @@ The following code illustrates how to allow a linear arrangement in diagram layo
-## Enable routing for layout
+## Enable Routing for Layout
-In some complex parent-child relationships, connectors may overlap nodes in the layout. To address this issue, you can utilize the enableRouting functionality. This feature finds a connector path that avoids any obstacles.
+In complex diagrams with intricate parent-child relationships, connectors may pass through or overlap with nodes, making the diagram difficult to read. Routing functionality automatically calculates connector paths that avoid intersecting with nodes and other obstacles.
-To enable routing in the layout, set the [`enableRouting`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#enablerouting) property to true.
+Set the [`enableRouting`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#enablerouting) property to **true** to activate intelligent connector routing.
The following example shows how to activate enableRouting in the layout:
@@ -118,3 +119,11 @@ The following example shows how to activate enableRouting in the layout:
{% endtabs %}
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/complexhiertree-cs5" %}
+
+## Best Practices
+
+- Use data source binding for dynamic content and better maintainability.
+- Enable line distribution when dealing with nodes that have multiple connections.
+- Consider enabling routing for complex layouts to improve visual clarity.
+- Test layout performance with large datasets and optimize as needed.
+- Ensure proper module injection for advanced features like line distribution.
\ No newline at end of file
diff --git a/ej2-react/diagram/connector-bezier.md b/ej2-react/diagram/connector-bezier.md
index b13c8c585..2731d3014 100644
--- a/ej2-react/diagram/connector-bezier.md
+++ b/ej2-react/diagram/connector-bezier.md
@@ -1,18 +1,18 @@
---
layout: post
-title: Bezier connectors in React Diagram component | Syncfusion®
-description: Learn here all about Connectors in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Bezier Connectors in React Diagram Component | Syncfusion®
+description: Learn to create, edit, and customize Bezier connectors in the Syncfusion React Diagram. Master smooth, interactive, and precise curved connections.
control: Connectors
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Bezier Connectors in EJ2 React Diagram control
+# Bezier Connectors in Diagram Component
-Bezier segments are used to create curve segments and the curves are configurable either with the control points or with vectors.
+Bezier segments create curved paths whose shape can be configured using either control points or vectors.
-To create a bezier segment, the [`segment.type`](https://ej2.syncfusion.com/react/documentation/api/diagram/segments) is set as `bezier` and need to specify [`type`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#type) for the connector.
+To create a bezier segment, the [`segment.type`](https://ej2.syncfusion.com/react/documentation/api/diagram/segments) is set as **bezier** and need to specify [`type`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#type) for the connector.
The following code example illustrates how to create a default bezier segment.
@@ -27,23 +27,22 @@ The following code example illustrates how to create a default bezier segment.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorsBezier-cs1" %}
-## Bezier segment editing
+## Bezier Segment Editing
-* A segment control point of the Bezier connector is used to change the bezier vectors and points of the connector.
+The shape of a Bezier connector can be interactively modified by dragging its segment control points. These points, also known as thumbs, appear along the connector and allow you to adjust the curve's vectors and points.

### Control Points
-* Bezier control points can be positioned in two ways.
+The curvature of a Bezier segment is determined by its control points. There are two primary ways to define the position of these control points:
-* When setting control point positions using the The [`point1`](https://helpej2.syncfusion.com/react/documentation/api/diagram/bezierSegment/#point1) and [`point2`](https://helpej2.syncfusion.com/react/documentation/api/diagram/bezierSegment/#point2) properties, the control point remains fixed in its set position while dragging connector end points.
-* When setting control point positions using the [`vector1`](https://helpej2.syncfusion.com/react/documentation/api/diagram/bezierSegment/#vector1) and [`vector2`](https://helpej2.syncfusion.com/react/documentation/api/diagram/bezierSegment/#vector2) properties, the control point dynamically adjusts to maintain the angle and distance originally set while moving the connector end points.
+* **Fixed Positioning (`point1`, `point2`)**: When you use the [`point1`](https://helpej2.syncfusion.com/react/documentation/api/diagram/bezierSegment/#point1) and [`point2`](https://helpej2.syncfusion.com/react/documentation/api/diagram/bezierSegment/#point2) properties, the control points are set at fixed coordinates. These points remain stationary even when the connector's start or end points are moved. This is useful for creating static, predictable curves.
#### Point
-The [`point1`](https://helpej2.syncfusion.com/react/documentation/api/diagram/bezierSegment/#point1) and [`point2`](https://helpej2.syncfusion.com/react/documentation/api/diagram/bezierSegment/#point2) properties of bezier segment enable you to set the control points. The following code example illustrates how to configure the bezier segments with control points.
+The `point1 ` and `point2`(https://helpej2.syncfusion.com/react/documentation/api/diagram/bezierSegment/#point2) properties of bezier segment enable you to set the control points. The following code example illustrates how to configure the bezier segments with control points.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -75,9 +74,9 @@ The [`vector1`](https://helpej2.syncfusion.com/react/documentation/api/diagram/b

-### Avoid overlapping with bezier
+### Avoid Overlapping with Bezier
-By default, when there are no segments defined for a bezier connector, the bezier segments will be created automatically and routed in such a way that avoids overlapping with the source and target nodes.
+By default, if no segments are explicitly defined for a Bezier connector, the Diagram component automatically generates segments. This routing logic is designed to prevent the connector from overlapping with its connected source and target nodes, ensuring a clean and readable layout.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -90,15 +89,19 @@ By default, when there are no segments defined for a bezier connector, the bezie
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorBezierAvoidOverlapping-cs1" %}
-### Allow segment reset.
+### Allow Segment Reset.
-This feature allows users to choose whether to reset the control points of bezier segments when moving the source or target node. This decision empowers users to maintain control over the positioning of bezier curves, enhancing flexibility and precision in diagram editing.
+The `allowSegmentReset` property gives you control over whether a Bezier segment’s control points should be reset to their default positions when the source or target node is moved. This provides greater flexibility in maintaining custom curve shapes during diagram editing.
-#### With allow segment reset as true.
+#### `allowSegmentReset` is **true** (Default)
+
+When `allowSegmentReset` is **true**, moving a connected node will reset the Bezier control points, recalculating the curve.

-##### With allow segment reset as false.
+#### `allowSegmentReset` is **false**
+
+When `allowSegmentReset` is **false**, the custom positions of the control points are preserved when a connected node is moved, maintaining the user-defined curve.

@@ -113,11 +116,11 @@ This feature allows users to choose whether to reset the control points of bezie
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5Segmentreset-cs1" %}
-### How to customize Bezier Segment Thumb Size
+### How to Customize Bezier Segment Thumb Size
-Bezier segment thumbs default to size 10. This can be adjusted globally or for individual connectors using the [`segmentThumbSize`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#segmentthumbsize) property.
-To change the thumb size for all Bezier connectors, set the [`segmentThumbSize`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#segmentthumbsize) property in the diagram’s model.
-To customize the thumb size for a specific connector, disable the [`InheritSegmentThumbSize`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connectorConstraints/) constraint, then set the desired [`segmentThumbSize`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#segmentthumbsize).
+The interactive thumbs used to edit Bezier segments have a default size of 10×10 pixels. This size can be customized either globally for all connectors or individually for each connector using the [`segmentThumbSize`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#segmentthumbsize) property.
+To change the thumb size for all Bezier connectors, set the `segmentThumbSize` property in the diagram’s model.
+To customize the thumb size for a specific connector, disable the [`InheritSegmentThumbSize`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connectorConstraints/) constraint, then set the desired `segmentThumbSize.
{% tabs %}
diff --git a/ej2-react/diagram/connector-customization.md b/ej2-react/diagram/connector-customization.md
index 84b1aa666..59e1a5404 100644
--- a/ej2-react/diagram/connector-customization.md
+++ b/ej2-react/diagram/connector-customization.md
@@ -1,27 +1,28 @@
---
layout: post
-title: Connector customization in React Diagram component | Syncfusion®
-description: Learn here all about Connectors in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Connector Customization in React Diagram Component | Syncfusion®
+description: Learn how to customize connector properties such as decorator shapes, styles, and gradient effects in the Syncfusion React Diagram Component.
control: Connector customization
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Connector customization
-Diagram allows you to customize the connector appearances. The following topics shows how to customize several properties of the connectors.
+# Connector Customization
-To customize the appearance, padding, and bridging of the connectors in the React Diagram component, refer to the video link below.
+The Diagram component provides extensive customization options for connectors, allowing developers to modify visual appearance, behavior, and interaction properties. This guide covers decorator shapes, styling options, spacing controls, bridging effects, and advanced connector features.
-{% youtube "https://www.youtube.com/watch?v=pn02S_rwupw" %}
+## Decorator Shapes and Customization
-## Decorator
+Decorators are visual elements that appear at the starting and ending points of connectors, typically used to indicate direction or relationship types such as arrows, circles, diamonds, or custom shapes.
+
+### Basic Decorator Configuration
* Starting and ending points of a connector can be decorated with some customizable shapes like arrows, circles, diamond, or path. The connection end points can be decorated with the [`sourceDecorator`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#sourcedecorator) and [`targetDecorator`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#targetdecorator) properties of the connector.
-* The [`shape`](https://helpej2.syncfusion.com/react/documentation/api/diagram/decoratorShapes/) property of `sourceDecorator` allows to define the shape of the decorators. Similarly, the [shape](https://helpej2.syncfusion.com/react/documentation/api/diagram/decoratorShapes/) property of `targetDecorator` allows to define the shape of the decorators.
+* The [`shape`](https://helpej2.syncfusion.com/react/documentation/api/diagram/decoratorShapes/) property of `sourceDecorator` allows to define the shape of the decorators. Similarly, the `shape` property of `targetDecorator` allows to define the shape of the decorators.
-* To create custom shape for source decorator, use [`pathData`](https://helpej2.syncfusion.com/react/documentation/api/diagram/decorator/#pathdata) property. Similarly, to create custom shape for target decorator, use [`pathData`](https://helpej2.syncfusion.com/react/documentation/api/diagram/decorator/#pathdata) property.
+* To create custom shape for source decorator, use the [`pathData`](https://helpej2.syncfusion.com/react/documentation/api/diagram/decorator/#pathdata) property to define SVG path strings for both source and target decorators.
* The following code example illustrates how to create decorators of various shapes.
@@ -36,13 +37,15 @@ To customize the appearance, padding, and bridging of the connectors in the Reac
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorDecorators-cs1" %}
-### Customize the decorator appearance
+### Customize the Decorator Appearance
+
+The visual appearance of decorators can be customized using stroke and fill properties to match design requirements or highlight specific connector types.
* The source decorator’s [`strokeColor`](https://helpej2.syncfusion.com/react/documentation/api/diagram/strokeStyle/#strokecolor), [`strokeWidth`](https://helpej2.syncfusion.com/react/documentation/api/diagram/strokeStyle/#strokewidth), and [`strokeDashArray`](https://helpej2.syncfusion.com/react/documentation/api/diagram/strokeStyle/#strokedasharray) properties are used to customize the color, width, and appearance of the decorator.
-* To set the border stroke color, stroke width, and stroke dash array for the target decorator, use [`strokeColor`](https://helpej2.syncfusion.com/react/documentation/api/diagram/strokeStyle/#strokecolor), [`strokeWidth`](https://helpej2.syncfusion.com/react/documentation/api/diagram/strokeStyle/#strokewidth), and [`strokeDashArray`](https://helpej2.syncfusion.com/react/documentation/api/diagram/strokeStyle/#strokedasharray).
+* To set the border stroke color, stroke width, and stroke dash array for the target decorator, use [`strokeColor`](https://helpej2.syncfusion.com/react/documentation/api/diagram/strokeStyle/#strokecolor), `strokeWidth` , and `strokeDashArray`.
-* To set the size for source and target decorator, use width and height property.
+* To set the size for source and target decorator, use width and height properties.
The following code example illustrates how to customize the appearance of the decorator.
@@ -57,13 +60,15 @@ The following code example illustrates how to customize the appearance of the de
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorsDecorator-cs1" %}
-### Gradient style for decorator.
+### Gradient Styling for Decorators
-The gradient property is used to set the gradient color for the decorator. There are two types of gradient.
- * Linear
- * Radial
+The gradient property applies smooth color transitions to decorators, providing enhanced visual appeal for complex diagrams or when highlighting important connections.
-The following code example illustrates how to apply gradient for the decorator.
+The gradient property supports two types of gradients:
+ * Linear - Creates a straight-line color transition.
+ * Radial - Creates a circular color transition from center outward.
+
+The following code example illustrates how to apply gradient effects to decorators.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -76,9 +81,21 @@ The following code example illustrates how to apply gradient for the decorator.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorGradient-cs1" %}
-## Padding
+## Connector Appearance and Styling
+
+The visual appearance of connector segments can be customized to distinguish different types of connections or match application themes.
+
+The connector's `strokeWidth`, `strokeColor`, `strokeDashArray`, and [`opacity`](https://helpej2.syncfusion.com/react/documentation/api/diagram/strokeStyle/#opacity) properties are used to customize the appearance of the connector segments.
+
+The [`visible`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#visible) property of the connector enables or disables the visibility of the connector.
+
+Default values for all connectors can be set using the `getConnectorDefaults` properties. This is useful when all connectors share the same type or properties, allowing common settings to be centralized.
-Padding is used to leave the space between the Connector's end point and the object to where it is connected.
+## Spacing and Padding Controls
+
+### Padding between Connectors and Nodes
+
+Padding creates visual separation between connector endpoints and the nodes they connect, preventing connectors from appearing to touch or overlap with node boundaries.
* The [`sourcePadding`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#sourcepadding) property of connector defines space between the source point and the source node of the connector.
@@ -97,10 +114,12 @@ Padding is used to leave the space between the Connector's end point and the obj
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectNode-cs2" %}
-## Bridging
+## Advanced Connector Features
+
+### Line Bridging for Intersection Handling
-Line bridging creates a bridge for lines to smartly cross over the other lines, at points of intersection. By default, [`bridgeDirection`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#bridgedirection) is set to top. Depending upon the direction given bridging direction appears.
-Bridging can be enabled/disabled either with the `connector.constraints` or `diagram.constraints`. The following code example illustrates how to enable line bridging.
+Line bridging creates visual bridges where connectors intersect, helping users distinguish between different connection paths in complex diagrams. By default, [`bridgeDirection`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#bridgedirection) is set to top, with the bridge appearing based on the specified direction.
+Bridging can be enabled or disabled using either **connector.constraints** or **diagram.constraints**. The following code example illustrates how to enable line bridging.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -113,17 +132,17 @@ Bridging can be enabled/disabled either with the `connector.constraints` or `dia
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorsBridging-cs1" %}
-N> You need to inject connector bridging module into the diagram.
+N> The connector bridging module must be injected into the diagram to use this feature.
The [`bridgeSpace`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#bridgespace) property of connectors can be used to define the width for line bridging.
-Limitation: Bezier segments do not support bridging.
+**Limitation**: Bezier segments do not support bridging functionality.
-## Hit padding
+### Hit Padding for Interaction
-* The [`hitPadding`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#hitpadding) property enables you to define the clickable area around the connector path.The default value for hitPadding is 10.
+* The [`hitPadding`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#hitpadding) property defines the clickable area around the connector path, making it easier for users to select connectors, especially thin ones. This improves user experience by expanding the interactive zone without changing the visual appearance. The default value for hitPadding is 10.
-* The following code example illustrates how to specify hit padding for connector.
+* The following code example illustrates how to specify hit padding for connectors.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -136,9 +155,9 @@ Limitation: Bezier segments do not support bridging.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorHitPadding-cs1" %}
-## Corner radius
+## Corner Radius for Rounded Connectors
-Corner radius allows to create connectors with rounded corners. The radius of the rounded corner is set with the [`cornerRadius`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#cornerradius) property.
+Corner radius creates connectors with rounded corners instead of sharp angles, providing a more polished appearance for diagrams. The radius of the rounded corner is set with the [`cornerRadius`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#cornerradius) property.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -153,13 +172,13 @@ Corner radius allows to create connectors with rounded corners. The radius of th
## Connector Appearance
-* The connector’s [`strokeWidth`](https://helpej2.syncfusion.com/react/documentation/api/diagram/strokeStyle/#strokewidth), [`strokeColor`](https://helpej2.syncfusion.com/react/documentation/api/diagram/strokeStyle/#strokecolor), [`strokeDashArray`](https://helpej2.syncfusion.com/react/documentation/api/diagram/strokeStyle/#strokedasharray), and [`opacity`](https://helpej2.syncfusion.com/react/documentation/api/diagram/strokeStyle/#opacity) properties are used to customize the appearance of the connector segments.
+* The connector’s `strokeWidth`, `strokeColor`, `strokeDashArray`, and `opacity`] properties are used to customize the appearance of the connector segments.
* The [`visible`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#visible) property of the connector enables or disables the visibility of connector.
* Default values for all the `connectors` can be set using the `getConnectorDefaults` properties. For example, if all connectors have the same type or having the same property then such properties can be moved into `getConnectorDefaults`.
-### Segment appearance
+### Segment Appearance
The following code example illustrates how to customize the segment appearance.
@@ -174,13 +193,13 @@ The following code example illustrates how to customize the segment appearance.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorsAppearance-cs1" %}
-## Connector constraints
+## Connector Constraints and Behavior
* The [`constraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#constraints) property of connector allows to enable/disable certain features of connectors.
-* To enable or disable the constraints, refer [`constraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#constraints).
+* To enable or disable the constraints, refer `constraints`.
-The following code illustrates how to disable selection.
+The following code illustrates how to disable selection for a connector.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -193,9 +212,11 @@ The following code illustrates how to disable selection.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorsConstraints-cs1" %}
-## Add info for connector
+## Additional Connector Properties
-The [`addInfo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#addinfo) property of connectors allow you to maintain additional information to the connectors.
+### Adding Custom Information
+
+The [`addInfo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#addinfo) property of connectors allows maintaining additional information or metadata associated with connectors for application-specific requirements.
``` ts
@@ -210,11 +231,11 @@ var connectors = {
```
-## ZIndex for connector
+## ZIndex for Connector
-The connectors [`zIndex`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#zindex) property specifies the stack order of the connector. A connector with greater stack order is always in front of a connector with a lower stack order.
+The connectors [`zIndex`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#zindex) property specifies the stack order of connectors. A connector with a greater stack order appears in front of connectors with lower stack orders, enabling precise control over visual layering.
-The following code illustrates how to render connector based on the stack order.
+The following code illustrates how to render connectors based on stack order.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -227,9 +248,11 @@ The following code illustrates how to render connector based on the stack order.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5zindex-cs1" %}
-## Connector spacing
+### Connector Spacing for Routing
+
+* The [`connectorSpacing`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#connectorspacing) property defines the minimum distance between the source node and the connector when automatic routing occurs. This determines how far the connector will reroute around obstacles or the minimum length for new segments.
-* The [`connectorSpacing`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#connectorspacing) property allows you to define the distance between the source node and the connector. It is the minimum distance the connector will re-rout or the new segment will create.
+The following code example illustrates how to configure connector spacing.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -242,9 +265,9 @@ The following code illustrates how to render connector based on the stack order.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorsDecAppearance-cs1" %}
-## MaxSegment thumb
+#### Maximum Segment Thumbs
-The property [`maxSegmentThumb`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#maxsegmentthumb) is used to limit the number of segment thumb in the connector.
+The [`maxSegmentThumb`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#maxsegmentthumb)property limits the number of segment manipulation handles displayed on a connector, helping maintain clean interfaces in complex diagrams.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -259,9 +282,9 @@ The property [`maxSegmentThumb`](https://helpej2.syncfusion.com/react/documentat

-## Reset segments
+## Reset Segments
-The [`resetSegments`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#resetsegments) method resets the segments of connectors to their default state based on their connection points. This operation removes any custom segments and restores the connectors to their original configuration. The following example demonstrates how to reset connector segments at runtime.
+The [`resetSegments`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#resetsegments) method resets connector segments to their default state based on connection points. This operation removes custom segments and restores connectors to their original configuration, useful for cleaning up user modifications.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -274,11 +297,13 @@ The [`resetSegments`](https://helpej2.syncfusion.com/react/documentation/api/dia
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ResetSegment-cs1" %}
-## Enable Connector Splitting
+## Dynamic Connector Manipulation
+
+### Enable Connector Splitting
-The connectors are used to create a link between two points, ports, or nodes to represent the relationship between them. Split the connector between two nodes when dropping a new node onto an existing connector and create a connection between the new node and existing nodes by setting the [`enableConnectorSplit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#enableconnectorsplit) as true. The default value of the [`enableConnectorSplit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#enableconnectorsplit) is false
+Connector splitting allows creating new connections when a node is dropped onto an existing connector. The connector splits at the drop point, creating connections between the new node and the existing connected nodes. Enable this feature by setting [`enableConnectorSplit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#enableconnectorsplit) to **true**. The default value is **false**.
-The following code illustrates how to split the connector and create a connection with new node.
+The following code illustrates how to enable connector splitting functionality..
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -293,11 +318,11 @@ The following code illustrates how to split the connector and create a connectio

-### Preserve connector style while connector splitting
+### Preserve Connector Styling During Splitting
-When splitting a connector using [`enableConnectorSplit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#enableconnectorsplit), the new connector created will be a normal connector without any specific styles. To ensure the new connector has the same style as the original connector, you can use the collectionChange event to apply the styles.
+When splitting a connector using [`enableConnectorSplit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#enableconnectorsplit), the newly created connector appears as a default connector without inheriting the original connector's styling. To maintain consistent styling, use the collectionChange event to apply the original connector's properties to the new connector.
-The following example demonstrates how to apply the same style of the original connector to the newly added connector:
+The following example demonstrates how to preserve the original connector's styling for newly created connectors during splitting:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/connector-events.md b/ej2-react/diagram/connector-events.md
index 570ea2d8b..f1730a833 100644
--- a/ej2-react/diagram/connector-events.md
+++ b/ej2-react/diagram/connector-events.md
@@ -1,20 +1,22 @@
---
layout: post
-title: Connector Events in React Diagram component | Syncfusion®
-description: Learn here all about Connectors in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Connector Events in React Diagram Component | Syncfusion®
+description: Learn about connector events in Syncfusion® React Diagram Component, including click, selection, position, connection, and segment events with examples.
control: Connector Events
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Events
+# Connector Events in React Diagram
-Diagram provides some events support for connectors that triggers when interacting with the connector.
+The Diagram component provides comprehensive event support for connectors, allowing developers to respond to various user interactions and programmatic changes. These events enable dynamic behavior and custom logic when users interact with connectors through clicking, dragging, connecting, or modifying segments.
-## Click event
+## Click Event
-Triggers when the connector is clicked. The following code example explains how to get the [`click`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iClickEventArgs/) event in the diagram.
+Triggers when a connector is clicked by the user. This event is useful for implementing custom actions, showing context menus, or displaying connector-specific information.
+
+The following code example demonstrates how to handle the [`click`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iClickEventArgs/) event in the diagram.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -27,10 +29,11 @@ Triggers when the connector is clicked. The following code example explains how
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ClickEvent-cs1" %}
-## Selection change event
+## Selection Change Event
+
+Triggers when a connector is selected or unselected. This event allows you to implement custom selection logic, update property panels, or perform actions based on selection state changes.
-When selecting/unselecting the connector, the selection change event will be triggered.
-The following code example explains how to get the [`selection change`](https://ej2.syncfusion.com/react/documentation/api/diagram/#selectionchange) event in the diagram.
+The following code example demonstrates how to handle the [`selectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#selectionchange) event in the diagram:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -43,7 +46,7 @@ The following code example explains how to get the [`selection change`](https://
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5SelectionChangeEvent-cs1" %}
- You can prevent selection by setting the `cancel` property of [`SelectionChangeEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/iselectionchangeeventargs/) to true, as shown in the code snippet below.
+ You can prevent selection by setting the `**cancel**` property of [`SelectionChangeEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/iselectionchangeeventargs/) to **true**, as shown in the code snippet below:
```js
selectionChange= { (args) => {
@@ -56,10 +59,11 @@ The following code example explains how to get the [`selection change`](https://
```
-## Position change event
+## Position Change Event
+
+Triggers when a connector's position changes during dragging operations. This event is essential for implementing validation, snapping behavior, or custom positioning logic.
-Triggers when the connector's position is changed in diagram.
-The following code example explains how to get the [`position change`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iDraggingEventArgs/) event in the diagram.
+The following code example demonstrates how to handle the [`positionChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iDraggingEventArgs/) event in the diagram:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -72,7 +76,7 @@ The following code example explains how to get the [`position change`](https://h
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5PositionChangeEvent-cs1" %}
- You can prevent dragging by setting the `cancel` property of [`DraggingEventArgs`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iDraggingEventArgs/) to true, as shown in the code snippet below.
+ You can prevent dragging by setting the `cancel` property of [`DraggingEventArgs`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iDraggingEventArgs/) to **true**, as shown in the code snippet below.
```js
positionChange={ (args) => {
@@ -85,10 +89,11 @@ The following code example explains how to get the [`position change`](https://h
```
-## Connection change event
+## Connection Change Event
-Triggers when the connector’s source or target point is connected or disconnected from the source or target.
-The following code example explains how to get the [`connection change`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iConnectionChangeEventArgs/) event in the diagram.
+Triggers when a connector's source or target point connects to or disconnects from nodes. This event is crucial for implementing connection validation, automatic routing updates, or maintaining data relationships.
+
+The following code example demonstrates how to handle the [`connectionChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iConnectionChangeEventArgs/) event in the diagram.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -101,10 +106,11 @@ The following code example explains how to get the [`connection change`](https:/
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectionChangeEvent-cs1" %}
-## Source Point change event
+## Source Point Change Event
+
+Triggers when a connector's source point is modified through dragging or programmatic changes. This event enables validation of source connections and implementation of custom connection rules.
-Triggers when the connector's source point is changed.
-The following code example explains how to get the [`source Point change`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iEndChangeEventArgs/) event in the diagram.
+The following code example demonstrates how to handle the [`sourcePointChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iEndChangeEventArgs/) event in the diagram.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -117,7 +123,7 @@ The following code example explains how to get the [`source Point change`](https
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5SourcePointchange-cs1" %}
- You can prevent source point dragging by setting the `cancel` property of [`EndChangeEventArgs`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iEndChangeEventArgs/) to true, as shown in the code snippet below.
+ You can prevent source point dragging by setting the `cancel` property of [`EndChangeEventArgs`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iEndChangeEventArgs/) to **true**, as shown in the code snippet below:
```javascript
@@ -132,10 +138,11 @@ The following code example explains how to get the [`source Point change`](https
```
-## Target Point change event
+## Target Point Change Event
-Triggers when the connector's target point is changed.
-The following code example explains how to get the [`target Point change`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iEndChangeEventArgs/) event in the diagram.
+Triggers when a connector's target point is modified through dragging or programmatic changes. This event allows validation of target connections and enforcement of connection constraints.
+
+The following code example demonstrates how to handle the [`targetPointChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iEndChangeEventArgs/) event in the diagram.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -148,7 +155,7 @@ The following code example explains how to get the [`target Point change`](https
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5TargetPontChange-cs1" %}
- You can prevent target point dragging by setting the `cancel` property of [`EndChangeEventArgs`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iEndChangeEventArgs/) to true, as shown in the code snippet below.
+ You can prevent target point dragging by setting the `cancel` property of [`EndChangeEventArgs`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iEndChangeEventArgs/) to **true**, as shown in the code snippet below.
```javascript
@@ -163,12 +170,13 @@ targetPointChange={ (args) => {
```
-## Segment Collection Change event
+## Segment Collection Change Event
+
+Triggers when connector segments are added or removed at runtime. This event is essential for tracking dynamic changes to connector paths and implementing custom segment management logic.
-Triggers when the connector's segments added or removed at runtime.
-The following code example explains how to get the [`segment collection change`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iSegmentCollectionChangeEventArgs/) event in the diagram.
+The following code example demonstrates how to handle the [`segmentCollectionChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iSegmentCollectionChangeEventArgs/) event in the diagram:
-Use `CTRL+Shift+Click` on connector to add/remove segments.
+Use **CTRL+Shift+Click** on connector to add/remove segments.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -181,10 +189,11 @@ Use `CTRL+Shift+Click` on connector to add/remove segments.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5SegmentCollChange-cs1" %}
-## Segment Change event
+## Segment Change Event
-Triggers when the connector's segments were adjusted or edited.
-The following code example explains how to get the [`segment change`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iSegmentChangeEventArgs/) event in the diagram.
+Triggers when connector segments are adjusted or edited by the user. This event enables custom validation and modification of segment positions during interactive editing.
+
+The following code example demonstrates how to handle the [`segmentChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iSegmentChangeEventArgs/) event in the diagram:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -197,7 +206,7 @@ The following code example explains how to get the [`segment change`](https://he
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5SegmentChangeEvent-cs1" %}
- You can prevent segment editing by setting the `cancel` property of [`SegmentChangeEventArgs`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iSegmentChangeEventArgs/) to true, as shown in the code snippet below.
+ You can prevent segment editing by setting the `cancel` property of [`SegmentChangeEventArgs`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iSegmentChangeEventArgs/) to **true**, as shown in the code snippet below:
``` javascript
segmentChange={ (args) => {
@@ -210,10 +219,11 @@ The following code example explains how to get the [`segment change`](https://he
```
-## Collection change event
+## Collection Change Event
+
+Triggers when connectors are added to or removed from the diagram. This event is fundamental for tracking diagram modifications and implementing undo/redo functionality or change tracking systems.
-Triggers when the connector is added or removed from diagram.
-The following code example explains how to get the [`collection change`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iCollectionChangeEventArgs/) event in the diagram.
+The following code example demonstrates how to handle the [`collectionChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iCollectionChangeEventArgs/) event in the diagram.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -226,7 +236,7 @@ The following code example explains how to get the [`collection change`](https:/
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5CollectionChange-cs1" %}
-You can prevent changes to the diagram collection, such as adding or deleting connectors, by setting the `cancel` property of [`CollectionChangeEventArgs`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iCollectionChangeEventArgs/) to true, as shown in the code snippet below.
+You can prevent changes to the diagram collection, such as adding or deleting connectors, by setting the `cancel` property of [`CollectionChangeEventArgs`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iCollectionChangeEventArgs/) to **true**, as shown in the code snippet below:
``` javascript
collectionChange={ (args) => {
diff --git a/ej2-react/diagram/connector-interaction.md b/ej2-react/diagram/connector-interaction.md
index 516e46713..d080fe9b7 100644
--- a/ej2-react/diagram/connector-interaction.md
+++ b/ej2-react/diagram/connector-interaction.md
@@ -1,22 +1,22 @@
---
layout: post
-title: Connector Interaction in React Diagram component | Syncfusion®
-description: Learn here all about Connectors in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Connector Interaction in React Diagram Component | Syncfusion®
+description: Explore how to interact with connectors in the Syncfusion React Diagram Component, including selection, dragging, endpoint manipulation, and flipping.
control: Connector Interaction
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Connector interaction in EJ2 React Diagram
+# Connector Interaction in EJ2 React Diagram Component
-Connectors can be selected, dragged, and routed over the diagram page.
+Connectors in the React Diagram component support various interaction capabilities including selection, dragging, endpoint manipulation, segment editing, and flipping operations. These interactions enable users to dynamically modify connector behavior and appearance within the diagram.
-## Select and unSelect connector.
+## Select and Unselect connector
-A connector can be selected, simply just by clicking on it.
+A connector can be selected by clicking on it. This selection enables further operations such as dragging, editing, or applying transformations.
-A connector can be selected at runtime by using the Select method and clear the selection in the diagram using the ClearSelection. The following code explains how to select and clear selection in the diagram.
+Connectors can be selected programmatically at runtime using the **select** method and selection can be cleared using the **clearSelection** method. The following code demonstrates how to select and clear selection in the diagram.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -31,7 +31,7 @@ A connector can be selected at runtime by using the Select method and clear the
## Drag Connector
-Connector can be dragged by just clicking on the connector and dragging.
+Connectors can be repositioned by clicking and dragging them to a new location within the diagram canvas.

@@ -48,15 +48,15 @@ A connector can be dragged at runtime by using the Drag method. The following co
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5DragConnector-cs1" %}
-## End point dragging
+## End Point Dragging
-The connector can be selected by clicking it. When the connector is selected, circles will be added on the starting and ending of the connector that is represented by Thumbs. Clicking and dragging those handles helps you to adjust the source and target points.
+When a connector is selected, circular handles (thumbs) appear at the source and target endpoints. These handles allow users to adjust the connector's start and end positions by clicking and dragging them.

-You can also update the endPoints of diagram by using [`dragSourceEnd`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#dragsourceend) and [`dragTargetEnd`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#dragtargetend) methods of diagram.
+The end points of connectors can also be updated programmatically using the [`dragSourceEnd`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#dragsourceend) and [`dragTargetEnd`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#dragtargetend) methods of the diagram component.
-The following code example shows the ways to drag connector end point at runtime.
+The following code example demonstrates how to drag connector end points at runtime.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -69,9 +69,9 @@ The following code example shows the ways to drag connector end point at runtime
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5dragEnd-cs1" %}
-## Segment editing
+## Segment Editing
-Diagram allows you to edit connector segments at runtime. To enable this feature, you need to activate the [`DragSegmentThumb`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#constraints) constraint for the connector.
+The diagram allows editing of individual connector segments at runtime. To enable this feature, activate the [`DragSegmentThumb`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#constraints) constraint for the connector.
```ts
{ connector.constraints =
@@ -80,24 +80,22 @@ Diagram allows you to edit connector segments at runtime. To enable this feature
```
-N> To edit a connector segment, you need to inject the `ConnectorEditing` module into the diagram.
+N> To edit connector segments, inject the **ConnectorEditing** module into the diagram.

## Flip
-The diagram Provides support to flip the connector. The [`flip`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#flip) is performed to give the mirrored image of the original element.
+The diagram provides support for flipping connectors to create mirrored versions of the original element. The [`flip`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#flip) operation transforms the connector based on the specified flip direction.
-The flip types are as follows:
+The available flip types are:
-* HorizontalFlip
- [`Horizontal`](https://helpej2.syncfusion.com/react/documentation/api/diagram/flipDirection/) is used to interchange the connector source and target x points.
+* **Horizontal Flip** - [`Horizontal`](https://helpej2.syncfusion.com/react/documentation/api/diagram/flipDirection/) interchanges the connector source and target x coordinates.
-* VerticalFlip
-[`Vertical`](https://helpej2.syncfusion.com/react/documentation/api/diagram/flipDirection/) is used to interchange the connector source and target y points.
+* **Vertical Flip** - [`Vertical`](https://helpej2.syncfusion.com/react/documentation/api/diagram/flipDirection/) interchanges the connector source and target y coordinates.
+
+* **Both** - [`Both`](https://helpej2.syncfusion.com/react/documentation/api/diagram/flipDirection/) swaps the source point as the target point and the target point as the source point.
-* Both
-[`Both`](https://helpej2.syncfusion.com/react/documentation/api/diagram/flipDirection/) is used to interchange the source point as target point and target point as source point
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -110,4 +108,4 @@ The flip types are as follows:
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectNode-cs3" %}
- N> The flip is not applicable when the connectors connect in nodes
\ No newline at end of file
+ N> The flip operation is not applicable when connectors are connected to nodes.
\ No newline at end of file
diff --git a/ej2-react/diagram/connector-labels.md b/ej2-react/diagram/connector-labels.md
index c9a41b6f6..d64ca8808 100644
--- a/ej2-react/diagram/connector-labels.md
+++ b/ej2-react/diagram/connector-labels.md
@@ -8,23 +8,25 @@ documentation: ug
domainurl: ##DomainURL##
---
-# Connector annotations in React Diagram component
+# Connector Annotations in React Diagram Component
-Annotations of a connector can be positioned using the following properties of Annotation class.
+Connector annotations are text labels that can be positioned along connector paths to provide descriptive information or context. These annotations offer flexible positioning and styling options to enhance diagram readability and communication.
-* Offset
-* Alignment
-* Displacement
-* SegmentAngle
-* HorizontalAlignment
-* VerticalAlignment
-* Margin
+Annotations on connectors can be precisely positioned and customized using the following properties of the Annotation class:
+
+* **Offset** - Controls position along the connector path (0 to 1).
+* **Alignment** - Aligns annotation relative to connector segments.
+* **Displacement** - Moves annotation away from its calculated position.
+* **SegmentAngle** - Rotates annotation based on connector direction.
+* **HorizontalAlignment** - Controls horizontal positioning.
+* **VerticalAlignment** - Controls vertical positioning.
+* **Margin** - Adds spacing around the annotation.
## Annotation offset
-The [`offset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pathAnnotationModel/#offset) for [`pathAnnotation`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pathAnnotationModel) is of type number and ranges from 0 to 1, from the source to the target point of the connector. By default, the offset value for a connector annotation is 0.5.
+The [`offset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pathAnnotationModel/#offset) for [`pathAnnotation`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pathAnnotationModel) accepts a number value ranging from 0 to 1, representing the position along the connector path from source to target point. An offset value of 0 positions the annotation at the source point, while 1 positions it at the target point. The default offset value is 0.5, which centers the annotation on the connector.
-The following code illustrates, how to set offset for the connector.
+The following code example demonstrates how to configure the offset for connector annotations:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -43,7 +45,11 @@ The following image shows the position of the annotation with respect to differe
## Annotation alignment
-The connector’s annotation can be aligned over its segment path using the [`alignment`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationAlignment/) property of annotation.
+Connector annotations can be aligned relative to their segment path using the [`alignment`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationAlignment/)property. This property offers three alignment options:
+
+* **Before** - Positions the annotation before the calculated offset point.
+* **Center** - Centers the annotation at the offset point (default).
+* **After** - Positions the annotation after the calculated offset point.
The following code example illustrates how to align connector annotations.
@@ -60,7 +66,9 @@ The following code example illustrates how to align connector annotations.
## Displacement of annotation
-[`Displacement`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pointModel/) refers displacement of an annotation from its actual position. A connector annotation can be displaced to a particular distance by using a displacement property of the pathAnnotation. The following example shows how to set displacement for the connector annotation.
+The [`Displacement`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pointModel/) property allows annotations to be moved away from their calculated position by a specified distance. This feature is particularly useful for avoiding overlaps with connector paths or improving visual clarity.
+
+The following example shows how to apply displacement to connector annotations:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -73,11 +81,13 @@ The following code example illustrates how to align connector annotations.
{% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Displacement-cs1" %}
-N> Displacement is only applicable when we use alignment as `After` or `Before`.
+N> Displacement is only applicable when we use alignment as **After** or **Before**.
## Segment angle for annotation
-The [`segmentAngle`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pathAnnotationModel/#segmentangle) property is used to rotate the annotation based on the connectors segment direction. By default, annotation will be rotated in the connector path. When you set `segmentAngle` as true, annotation will be rotated from its position based on the connector segment direction. The following code illustrates, how to set segment angle.
+The [`segmentAngle`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pathAnnotationModel/#segmentangle) property controls whether annotations rotate to match the connector segment direction. When set to **true**, annotations automatically rotate based on the angle of the connector segment they are positioned on, creating a more integrated visual appearance. When set to **false** (default), annotations maintain their original orientation regardless of connector direction.
+
+The following code example demonstrates how to configure segment angle rotation:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/connector-orthogonal.md b/ej2-react/diagram/connector-orthogonal.md
index 162421808..fe9272a45 100644
--- a/ej2-react/diagram/connector-orthogonal.md
+++ b/ej2-react/diagram/connector-orthogonal.md
@@ -1,18 +1,18 @@
---
layout: post
-title: Orthogonal connectors in React Diagram component | Syncfusion®
-description: Learn here all about Connectors in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Orthogonal connectors in React Diagram Component | Syncfusion®
+description: Learn to create, customize, and edit orthogonal connectors in the Syncfusion React Diagram Component. Explore segment editing, avoiding overlaps, and custom styling.
control: Orthogonal
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Orthogonal Connectors in React EJ2 Diagram control
+# Orthogonal Connectors in React Diagram Component
-Orthogonal segments is used to create segments that are perpendicular to each other.
+Orthogonal connectors use segments that are always perpendicular to each other, which is ideal for creating structured layouts in flowcharts or organizational charts.
-Set the segment [`type`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#type) as orthogonal to create a default orthogonal segment and need to specify [`type`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#type). The following code example illustrates how to create a default orthogonal segment.
+To create an orthogonal connector, set its [`type`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#type) property to **Orthogonal**. The following code example illustrates how to create a default orthogonal connector.
Multiple segments can be defined one after another. To create a connector with multiple segments, define and add the segments to [`connector.segments`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#segments) collection. The following code example illustrates how to create a connector with multiple segments.
@@ -31,7 +31,7 @@ The [`length`](https://helpej2.syncfusion.com/react/documentation/api/diagram/or
N> You need to mention the segment type as same as what you mentioned in connector type. There should be no contradiction between connector type and segment type.
-## Orthogonal segment editing
+## Orthogonal Segment Editing
* Orthogonal thumbs allow you to adjust the length of adjacent segments by clicking and dragging them.
* When necessary, some segments are added or removed automatically, while dragging the segment.
@@ -50,9 +50,9 @@ N> You need to mention the segment type as same as what you mentioned in connect

-## Avoid overlapping
+## Avoid Overlapping
-Orthogonal segments are automatically re-routed, in order to avoid overlapping with the source and target nodes. The following preview illustrates how orthogonal segments are re-routed.
+Orthogonal segments automatically reroute themselves to avoid overlapping with their connected source and target nodes. The following example illustrates how an orthogonal connector adjusts its path when a connected node is moved.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -65,9 +65,9 @@ Orthogonal segments are automatically re-routed, in order to avoid overlapping w
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorsOverlapping-cs1" %}
-## How to customize Orthogonal Segment Thumb Shape
+## How to Customize Orthogonal Segment Thumb Shape
-The orthogonal connector can have any number of segments in between the source and the target point. Segments are rendered with the circle shape by default. The [`segmentThumbShape`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#segmentthumbshape) property allows you to change the default shape of the segment thumb. The following predefined shapes are provided:
+The thumbs used to edit orthogonal segments are rendered as a `Circle` by default. You can change this shape using the diagram's[`segmentThumbShape`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#segmentthumbshape) property. The following predefined shapes are available:
| Shape name | Shape |
|-------- | -------- |
@@ -84,7 +84,7 @@ The orthogonal connector can have any number of segments in between the source a
| OutdentedArrow |  |
| DoubleArrow | |
-You can customize the style of the thumb shape by overriding the class e-orthogonal-thumb.
+You can also customize the style of the thumb shape by overriding the `e-orthogonal-thumb` CSS class.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -99,7 +99,7 @@ You can customize the style of the thumb shape by overriding the class e-orthogo

-Use the following CSS to customize the segment thumb shape.
+Use the following CSS to customize the segment thumb's appearance.
```scss
@@ -117,9 +117,9 @@ Use the following CSS to customize the segment thumb shape.
## How to customize Orthogonal Segment Thumb Size
-Orthogonal segment thumbs default to size 10. This can be adjusted globally or for individual connectors using the [`segmentThumbSize`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#segmentthumbsize) property.
-To change the thumb size for all Orthogonal connectors, set the [`segmentThumbSize`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#segmentthumbsize) property in the diagram’s model.
-To customize the thumb size for a specific connector, disable the [`InheritSegmentThumbSize`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connectorConstraints) constraint, then set the desired [`segmentThumbSize`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#segmentthumbsize).
+By default, orthogonal segment thumbs have a width and height of 10px. This can be customized for all connectors or for individual ones using the[`segmentThumbSize`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#segmentthumbsize) property.
+To change the thumb size for all orthogonal connectors in a diagram, set the `segmentThumbSize` property in the diagram model.
+To customize the thumb size for a specific connector, you must first disable its `InheritSegmentThumbSize` property. Then, you can set the connector's unique `segmentThumbSize` value.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -130,6 +130,4 @@ To customize the thumb size for a specific connector, disable the [`InheritSegme
{% endhighlight %}
{% endtabs %}
- {% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorsOrthoThumbSize-cs1" %}
-
-
+ {% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorsOrthoThumbSize-cs1" %}
\ No newline at end of file
diff --git a/ej2-react/diagram/connector-segments.md b/ej2-react/diagram/connector-segments.md
index af422f0b9..714166574 100644
--- a/ej2-react/diagram/connector-segments.md
+++ b/ej2-react/diagram/connector-segments.md
@@ -1,16 +1,20 @@
---
layout: post
-title: Segments in React Diagram component | Syncfusion®
-description: Learn here all about Connectors in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Segments in React Diagram Component | Syncfusion®
+description: Learn here all about Connector Segments in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Segments
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-## Segments in EJ2 React Connector
+# Connector Segments in React Diagram Component
-The path of the connector is defined with a collection of segments. There are three types of segments.
+Connector segments define the path and visual appearance of connectors between nodes or points in a diagram. The path of a connector is constructed using a collection of segments, where each segment represents a portion of the connector's route. Understanding and configuring these segments allows for precise control over connector appearance and routing behavior.
+
+## Segment Types
+
+The React Diagram component supports three primary types of connector segments, each serving different visual and functional requirements:
* Straight
* Orthogonal
diff --git a/ej2-react/diagram/connector-straight.md b/ej2-react/diagram/connector-straight.md
index 942c3140f..cd34c31d7 100644
--- a/ej2-react/diagram/connector-straight.md
+++ b/ej2-react/diagram/connector-straight.md
@@ -1,16 +1,20 @@
---
layout: post
-title: Straight Connectors in React Diagram component | Syncfusion®
-description: Learn here all about Connectors in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Straight Connectors in React Diagram Component | Syncfusion®
+description: Learn here all about Straight Connector Segments in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Straight
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-## Straight in EJ2 React Diagram Control
+# Straight Connector Segments
-To create a straight line, specify the [`type`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#type) of the segment as **straight** and add a straight segment to [`segments`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#segments) collection and need to specify [`type`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#type) for the connector.
+Straight connector segments create direct linear connections between two points in a diagram. These segments are the simplest form of connector routing, providing the shortest path between nodes or connection points. Straight segments are ideal when you need clean, unobstructed connections without intermediate directional changes.
+
+## Creating Straight Segments
+
+To create a straight line connector, specify the [`type`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#type) of the segment as **straight** and add a straight segment to [`segments`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#segments) collection and need to specify [`type`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#type) property for the connector itself. The following code example demonstrates how to create a basic straight segment connector.
The following code example illustrates how to create a default straight segment.
@@ -25,9 +29,9 @@ The following code example illustrates how to create a default straight segment.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorsSegments-cs1" %}
- The [`point`](https://ej2.syncfusion.com/react/documentation/api/diagram/straightSegment/#point) property of straight segment allows you to define the end point of it.
-
- The following code example illustrates how to define the end point of a straight segment.
+## Defining Segment End Points
+
+The [`point`](https://ej2.syncfusion.com/react/documentation/api/diagram/straightSegment/#point) property of a straight segment allows you to define its end point coordinates. This provides precise control over where each segment terminates, enabling complex connector paths composed of multiple straight segments. The following code example illustrates how to define the end point of a straight segment.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -40,11 +44,23 @@ The following code example illustrates how to create a default straight segment.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorsSegmentsPoints-cs1" %}
-### Straight segment editing
+## Straight Segment Editing
+
+The end point of each straight segment is represented by a visual thumb control that enables interactive editing of the segment position. This allows users to dynamically modify connector paths by dragging segment endpoints.
+
+### Adding Segments
+
+New segments can be inserted into a straight line connector by clicking on the connector while pressing Shift and Ctrl keys simultaneously (Ctrl+Shift+Click). This creates additional control points for more complex routing.
+
+### Removing Segments
+
+Straight segments can be removed by clicking the segment end point while holding Ctrl and Shift keys (Ctrl+Shift+Click). This simplifies the connector path by eliminating unnecessary way points.
+
+### Programmatic Editing
+
+You can also add or remove segments programmatically using the [`editSegment`](https://ej2.syncfusion.com/react/documentation/api/diagram/#editsegment) method of the diagram component. This provides API-level control over connector segment manipulation.
- End point of each straight segment is represented by a thumb that enables to edit the segment.
-Any number of new segments can be inserted into a straight line by clicking when Shift and Ctrl keys are pressed (Ctrl+Shift+Click).
-Straight segments can be removed by clicking the segment end point when Ctrl and Shift keys are pressed (Ctrl+Shift+Click). You can also add/remove segments by using the [`editSegment`](https://ej2.syncfusion.com/react/documentation/api/diagram/#editsegment) method of diagram.
+The following example demonstrates how to add segments to a straight connector programmatically.
The following example shows how to add segments at runtime for the straight connector.
diff --git a/ej2-react/diagram/connectors.md b/ej2-react/diagram/connectors.md
index a70b318aa..d791b97af 100644
--- a/ej2-react/diagram/connectors.md
+++ b/ej2-react/diagram/connectors.md
@@ -1,20 +1,20 @@
---
layout: post
-title: Connectors in React Diagram component | Syncfusion®
-description: Learn here all about Connectors in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Connectors in React Diagram Component | Syncfusion®
+description: Explore the various types of connectors available in the Syncfusion React Diagram Component and learn how to create, customize, and manage them.
control: Connectors
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Connectors in React Diagram component
+# Connectors in React Diagram Component
-Connectors are objects used to create link between two points, nodes or ports to represent the relationships between them.
+Connectors are objects used to create links between two points, nodes, or ports to represent relationships between them. They provide visual connections that help illustrate data flow, process sequences, hierarchical relationships, and other logical connections in diagrams.
-## Create connector
+## Create Connector
-Connector can be created by defining the source and target point of the connector. The path to be drawn can be defined with a collection of segments. To explore the properties of a [`connector`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/), refer to [`Connector Properties`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/). The [`id`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connectorModel/#id) property of a connector is used to define its unique identifier and can later be used to find the connector at runtime for customization.
+Connectors can be created by defining the source and target points. The path to be drawn can be defined with a collection of segments. To explore the properties of a [`connector`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/), refer to [`Connector Properties`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/). The [`id`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connectorModel/#id) property of a connector is used to define its unique identifier and can later be used to find the connector at runtime for customization.
```ts
let connectors = [{
@@ -26,7 +26,7 @@ let connectors = [{
```
N> When setting a Connector's ID, ensure that it does not contain white spaces, does not start with numbers or special characters, and does not include special characters like underscores (_) or spaces.
-## Add connectors through connectors collection
+## Add connectors through Connectors Collection
The [`sourcePoint`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#sourcepoint) and [`targetPoint`](https://ej2.syncfusion.com/react/documentation/api/diagram/connector/#targetpoint) properties of connector allow you to define the end points of a connector.
@@ -43,9 +43,9 @@ The following code example illustrates how to add a connector through connector
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5Connectors-cs1" %}
-## Add/remove connector at runtime
+## Add/Remove Connector at Runtime
-Connectors can be added at runtime by using public method, [`add`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#add) and can be removed at runtime by using public method, [`remove`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#remove).
+Connectors can be added at runtime by using public method, [`add`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#add) and can be removed at runtime by using public method, [`remove`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#remove).These methods are useful when you need to dynamically modify diagram structure based on user interactions or data changes.
The following code example illustrates how to add connector at runtime.
@@ -60,7 +60,7 @@ The following code example illustrates how to add connector at runtime.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5Connectorsatruntime-cs1" %}
-## Add collection of connectors at runtime
+## Add Collection of Connectors at Runtime
The collection of connectors can be dynamically added using [`addElements`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#addelements) method.Each time an element is added to the diagram canvas, the [`collectionChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#collectionchange) event will be triggered.
@@ -77,9 +77,9 @@ The following code illustrates how to add connectors collection at runtime.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectoraddatRunTime-cs2" %}
-## Add Connectors from palette
+## Add Connectors from Palette
-Connectors can be predefined and added to the symbol palette. You can drop those connectors into the diagram, when required.
+Connectors can be predefined and added to the symbol palette. You can drop those connectors into the diagram, when required. This approach is useful for creating reusable connector templates that users can easily drag and drop into their diagrams.
The following code example illustrates how to add connectors in palette.
@@ -94,11 +94,11 @@ The following code example illustrates how to add connectors in palette.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5Connectorfrompalette-cs1" %}
-## Draw connectors
+## Draw Connectors
-Connectors can be interactively drawn by clicking and dragging the diagram surface.
+Connectors can be interactively drawn by clicking and dragging on the diagram surface. This feature enables users to create connections dynamically during diagram creation or editing.
-To draw a shape, you have to activate the drawing tool by setting `DrawOnce` or `ContinuousDraw` to the [`tool`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#tool) property and you need to set the `connector` object by using the [`drawingObject`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#drawingobject) property.
+To draw a shape, you have to activate the drawing tool by setting **DrawOnce** or **ContinuousDraw** to the [`tool`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#tool) property and you need to set the `connector` object by using the [`drawingObject`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#drawingobject) property.
The following code example illustrates how to draw a connector at runtime.
@@ -113,11 +113,13 @@ The following code example illustrates how to draw a connector at runtime.
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectordrawTool-cs1" %}
-## Update connector at runtime
+ For more information about drawing connectors, refer to [`Draw Connectors`](https://ej2.syncfusion.com/react/documentation/api/diagram/#drawingobject).
+
+## Update Connector at Runtime
Various connector properties such as `sourcePoint`, `targetPoint`, `style`, `sourcePortID`, `targetPortID`, etc., can be updated at the runtime.
-The following code example illustrates how to update a connector's source point, target point, styles properties at runtime.
+The following code example illustrates how to update a connector's source point, target point, styles properties at runtime.This flexibility allows for dynamic modification of connector appearance and behavior based on application logic or user interactions.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -130,11 +132,11 @@ The following code example illustrates how to update a connector's source point,
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5Connectorsupdate-cs1" %}
-## Clone connector at runtime
+## Clone Connector at Runtime
-Cloning a connector creates a new connector instance with identical properties and attributes.
+Cloning a connector creates a new connector instance with identical properties and attributes. This feature is useful when you need to duplicate existing connectors while maintaining their configuration.
-The following code example illustrates how to clone a connector
+The following code example illustrates how to clone a connector.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -147,11 +149,11 @@ The following code example illustrates how to clone a connector
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorClone-cs1" %}
-## Get Connector defaults
+## Configure Default Connector Properties
-Get Connector defaults helps to define default properties of the connector. It is triggered when the diagram is initialized. In this event, you can customize the connector properties.
+The connector defaults functionality allows you to define default properties for all connectors in the diagram. This is triggered when the diagram is initialized, providing an opportunity to customize connector properties globally rather than setting them individually for each connector.
-The following code example explains how to customize the connector using [`getConnectorDefaults`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#getconnectordefaults).
+The following code example explains how to customize connector defaults using [`getConnectorDefaults`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#getconnectordefaults).
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -166,11 +168,11 @@ The following code example explains how to customize the connector using [`getCo
## Connections
-### Connection with nodes
+### Connection with Nodes
-* The [`sourceID`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#sourceid) and [`targetID`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#targetid) properties allow to define the nodes to be connected.
+* The [`sourceID`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#sourceid) and [`targetID`](https://helpej2.syncfusion.com/react/documentation/api/diagram/connector/#targetid) properties allow you to define the nodes to be connected. When these properties are set, the connector will automatically attach to the specified nodes and move with them when the nodes are repositioned.
-* The following code example illustrates how to connect two nodes.
+The following code example illustrates how to connect two nodes.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -185,9 +187,9 @@ The following code example explains how to customize the connector using [`getCo
* When you remove NodeConstraints [`InConnect`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeConstraints) from Default, the node accepts only an outgoing connection to dock in it. Similarly, when you remove NodeConstraints [`OutConnect`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeConstraints) from Default, the node accepts only an incoming connection to dock in it.
-* When you remove both InConnect and OutConnect NodeConstraints from Default, the node restricts connector to establish connection in it.
+When you remove both InConnect and OutConnect NodeConstraints from Default, the node restricts connectors from establishing connections to it.
-* The following code illustrates how to disable InConnect constraints.
+The following code illustrates how to disable InConnect constraints.
```ts
import * as React from "react";
@@ -223,9 +225,9 @@ root.render();
```
-## Connections with ports
+## Connections with Ports
-The [`sourcePortID`](https://ej2.syncfusion.com/react/documentation/api/diagram/connector/#sourceportid) and [`targetPortID`](https://ej2.syncfusion.com/react/documentation/api/diagram/connector/#targetportid) properties allow to create connections between some specific points of source/target nodes.
+The [`sourcePortID`](https://ej2.syncfusion.com/react/documentation/api/diagram/connector/#sourceportid) and [`targetPortID`](https://ej2.syncfusion.com/react/documentation/api/diagram/connector/#targetportid) properties allow you to create connections between specific points of source and target nodes. This provides more precise control over where connectors attach to nodes.
The following code example illustrates how to create port to port connections.
@@ -297,11 +299,11 @@ const root = ReactDOM.createRoot(document.getElementById('diagram'));
root.render();
```
-## Automatic line routing
+## Automatic Line Routing
-Diagram provides additional flexibility to re-route the diagram connectors. A connector will frequently re-route itself when a shape moves next to it.Routing adjusts the geometry of connectors to prevent them from overlapping with any nearby nodes in their path. This feature can be activated by adding the LineRouting constraints property to the diagram.
+Diagram provides additional flexibility to re-route diagram connectors automatically. A connector will frequently re-route itself when a shape moves next to it. Routing adjusts the geometry of connectors to prevent them from overlapping with any nearby nodes in their path. This feature can be activated by adding the LineRouting constraints property to the diagram.
-* Dependency LineRouting module should be injected to the application as the following code snippet.
+The LineRouting module should be injected to the application as shown in the following code snippet.
```ts
@@ -312,7 +314,7 @@ Diagram provides additional flexibility to re-route the diagram connectors. A co
Diagram.Inject(LineRouting);
```
-* Now, the line routing constraints must be included to the default diagram constraints to enable automatic line routing support like below.
+The line routing constraints must be included in the default diagram constraints to enable automatic line routing support as shown below.
```ts
/**
@@ -357,7 +359,7 @@ The following image illustrates how the connector automatically re-routes the se
{% previewsample "page.domainurl/code-snippet/diagram/connectors/es5ConnectorsLineRoutingDisabled-cs1" %}
-## Avoid line overlapping
+## Avoid Line Overlapping
The diagram provides flexibility to prevent connectors from overlapping, ensuring better clarity and readability. This feature intelligently adjusts connector paths to avoid stacking orthogonal connectors on top of each other, reducing visual clutter and enhancing diagram structure. It is especially useful in complex diagrams with multiple orthogonal connectors, where overlapping lines can make interpretation difficult.
@@ -408,8 +410,8 @@ N> The `AvoidLineOverlapping` feature applies only to orthogonal connectors and
## See Also
-* [How to add annotations to the connector](./labels)
-* [How to enable/disable the behavior of the node](./constraints)
-* [How to add connectors to the symbol palette](./symbol-palette)
-* [How to perform the interaction on the connector](./interaction#connection-editing)
-* [How to create diagram connectors using drawing tools](./tools)
\ No newline at end of file
+* [How to add annotations to the connector.](./labels)
+* [How to enable/disable the behavior of the node.](./constraints)
+* [How to add connectors to the symbol palette.](./symbol-palette)
+* [How to perform the interaction on the connector.](./interaction#connection-editing)
+* [How to create diagram connectors using drawing tools.](./tools)
\ No newline at end of file
diff --git a/ej2-react/diagram/constraints.md b/ej2-react/diagram/constraints.md
index a6997df67..35769f9fc 100644
--- a/ej2-react/diagram/constraints.md
+++ b/ej2-react/diagram/constraints.md
@@ -1,42 +1,43 @@
---
layout: post
-title: Constraints in React Diagram component | Syncfusion®
-description: Learn here all about Constraints in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Constraints in React Diagram Component | Syncfusion®
+description: Learn here all about Constraints in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Constraints
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Constraints in React Diagram component
+# Constraints in React Diagram Component
-Constraints are used to enable/disable certain behaviors of the diagram, nodes and connectors. Constraints are provided as flagged enumerations, so that multiple behaviors can be enabled/disabled using Bitwise operators (&, |, ~, <<, etc.).
+Constraints enable or disable specific behaviors of diagrams, nodes, and connectors. These constraints are implemented as flagged enumerations, allowing multiple behaviors to be controlled simultaneously using Bitwise operators (`&, |, ~, <<, etc.`).
To know more about Bitwise operators, refer to [`Bitwise Operations`](#bitwise-operations).
-## Diagram constraints
+## Diagram Constraints
-[`Diagram constraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramConstraints/) allows you to enable or disable the following behaviors:
+[`Diagram constraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramConstraints/) control the overall behavior and functionality of the diagram canvas.
The following table displays the list of all diagram constraints.
+
| Constraints | Description |
| -------- | -------- |
-|None|Disable all diagram functionalities.|
-|Bridging|Enables or disables Bridging support for connector in diagram.|
-|Undo/redo|Enables or disables the Undo/Redo support for the diagram.|
-|UserInteraction|Enables or disables user interaction support for the diagram.|
-|ApiUpdate|Enables or disables Api update support for the diagram.|
-|PageEditable|Enables or disables Page Editable support for the diagram.|
-|Zoom|Enables or disables Zoom support for the diagram.|
-|PanX|Enables or disables Panning X coordinate support for the diagram.|
-|PanY|Enables or disables Panning Y coordinate support for the diagram.|
-|Pan|Enables or disables panning both X and Y coordinates support for the diagram.|
-|ZoomTextEdit|Enables or disables zooming the text box while editing the text.|
-|Tooltip|Enables or disables the tooltip for the diagram.|
-|Virtualization|Enables or disables Virtualization support for the diagram.|
-|LineRouting|Enables or disables the line routing.|
-|Default|Enables or disables all constraints in diagram.|
+|None|Disables all diagram functionalities.|
+|Bridging|Enables bridging support for connectors in the diagram.|
+|Undo/redo|Enables undo and redo functionality for diagram operations.|
+|UserInteraction|Enables user interaction capabilities for the diagram.|
+|ApiUpdate|Enables programmatic updates through API calls.|
+|PageEditable|Enables editing within the page boundaries.|
+|Zoom|Enables zooming functionality for the diagram.|
+|PanX|Enables horizontal panning of the diagram.|
+|PanY|Enables vertical panning of the diagram.|
+|Pan|Enables both horizontal and vertical panning.|
+|ZoomTextEdit|Enables text box zooming during text editing operations.|
+|Tooltip|Enables tooltip display for diagram elements.|
+|Virtualization|Enables virtualization support for large diagrams.|
+|LineRouting|Enables automatic line routing for connectors.|
+|Default|Enables all default constraints for the diagram.|
The following example illustrates how to disable page editing using the diagram constraints.
@@ -107,43 +108,43 @@ N> By default, the following constraints are enabled in the diagram,
* PageEditable
* Default
-## Node constraints
+## Node Constraints
-Node constraints allows to enable or disable the following behaviors of node. They are as follows:
+Node constraints control the behavior and interactions available for individual nodes within the diagram.
| Constraints | Description |
| -------- | -------- |
-|None|Disable all node Constraints|
-|Select|Enables or disables the node to be selected.|
-|Drag|Enables or disables the node to be dragged.|
-|Rotate|Enables or disables the node to be rotated.|
-|Shadow|Enables or disables the node to display shadow.|
-|PointerEvents|Enables or disables the node to provide pointer option.|
-|Delete|Enables or disables node to be deleted.|
-|InConnect|Enables or disables node to provide in connect option.|
-|OutConnect|Enables or disables node to provide out connect option.|
-|AllowDrop|Enables node to provide allow to drop option.|
-|Individual|Enables node to provide individual resize option |
-|ResizeNorthEast|Enable or disable to resize NorthEast side of the node.|
-|ResizeEast|Enable or disable to resize East side of the node.|
-|ResizeSouthEast|Enable or disable to resize SouthEast side of the node.|
-|ResizeSouth|Enable or disable to resize South side of the node.|
-|ResizeSouthWest|Enable or disable to resize SouthWest side of the node.|
-|ResizeWest|Enable or disable to resize West side of the node.|
-|ResizeNorthWest|Enable or disable to resize NorthWest side of the node.|
-|ResizeNorth|Enable or disable to resize North side of the node.|
-|AspectRatio|Enables the Aspect ratio of the node.|
-|ReadOnly|Enables the ReadOnly support for annotation in the node.|
-|HideThumbs|Enable to hide all resize thumbs for the node.|
-|Tooltip|Enables or disables tooltip for the Nodes.|
-|InheritTooltip|Enables or disables inherit tooltip option from the parent object.|
-|Resize|Enables or Disables the expansion or compression of a node.|
-|Inherit|Enables the node to inherit the interaction option from the parent object.|
-|Expandable|Enables node to provide Expandable option|
-|AllowMovingOutsideLane| Enables or disables child in parent for the swimLane node |
+|None|Disables all node constraints.|
+|Select|Enables node selection capability.|
+|Drag|Enables node dragging functionality.|
+|Rotate|Enables node rotation capability.|
+|Shadow|Enables shadow display for the node.|
+|PointerEvents|Enables pointer event handling for the node.|
+|Delete|Enables node deletion capability.|
+|InConnect|Enables incoming connections to the node.|
+|OutConnect|Enables outgoing connections from the node.|
+|AllowDrop|Enables drop operations on the node.|
+|Individual|Enables individual resize handles for the node.|
+|ResizeNorthEast|Enables resizing from the northeast corner.|
+|ResizeEast|Enables resizing from the east side.|
+|ResizeSouthEast|Enables resizing from the southeast corner.|
+|ResizeSouth|Enables resizing from the south side.|
+|ResizeSouthWest|Enables resizing from the southwest corner.|
+|ResizeWest|Enables resizing from the west side.|
+|ResizeNorthWest|Enables resizing from the northwest corner.|
+|ResizeNorth|Enables resizing from the north side.|
+|AspectRatio|Maintains aspect ratio during resize operations.|
+|ReadOnly|Enables read-only mode for node annotations.|
+|HideThumbs|Hides all resize thumbs for the node.|
+|Tooltip|Enables tooltip display for the node.|
+|InheritTooltip|Inherits tooltip settings from parent objects.|
+|Resize|Enables overall resize functionality for the node.|
+|Inherit|Inherits interaction settings from parent objects.|
+|Expandable|Enables expand/collapse functionality for the node.|
+|AllowMovingOutsideLane|Allows movement outside swim lane boundaries.|
|Default|Enables all default constraints for the node.|
-The following example illustrates how to disable rotation using the node constraints.
+The following example demonstrates how to disable rotation using node constraints:
```ts
let nodes: NodeModel[] = [
@@ -163,7 +164,7 @@ const root = ReactDOM.createRoot(document.getElementById("diagram"));
root.render();
```
-The following example shows how to add Shadow constraint to the default constraints of node.
+The following example shows how to add shadow constraint to the default node constraints:
```ts
let nodes: NodeModel[] = [
@@ -183,7 +184,7 @@ const root = ReactDOM.createRoot(document.getElementById("diagram"));
root.render();
```
-The following code example shows how the tooltip can be enabled for the node.
+The following code example shows how to enable tooltip for a node:
```ts
let nodes: NodeModel[] = [
@@ -203,7 +204,7 @@ const root = ReactDOM.createRoot(document.getElementById("diagram"));
root.render();
```
-Multiple behaviors can be added or removed from the default constraints using the `Bitwise Operations`.
+Multiple behaviors can be added or removed from the default constraints using `Bitwise Operations`.
The following code example shows how to remove rotate and resize constraints from node.
@@ -261,38 +262,37 @@ N>By default, the following constraints are enabled for the node,
* InheritTooltip
* Default
-## Connector constraints
+## Connector Constraints
-Connector constraints allow to enable or disable certain behaviors of connectors.
+Connector constraints control the behavior and interactions available for connectors within the diagram.
| Constraints | Description |
| -------- | -------- |
-|None|Disable all connector Constraints.|
-|Select|Enables or disables connector to be selected.|
-|Delete|Enables or disables connector to be deleted.|
-|Drag|Enables or disables connector to be dragged.|
-|DragSourceEnd|Enables connectors source end to be selected.|
-|DragTargetEnd|Enables connectors target end to be selected.|
-|DragSegmentThumb|Enables control point and end point of every segment in a connector for editing.|
-|Interaction|Enables or disables Interaction for the connector.|
-|AllowDrop|Enables allow drop support to the connector.|
-|Bridging|Enables bridging to the connector.|
-|InheritBridging|Enables to inherit bridging option from the parent object.|
-|BridgeObstacle| Enables or Disables Bridge Obstacles with overlapping of connectors.|
-|PointerEvents|Enables to set the pointer events.|
-|ConnectToNearByNode|Enables to connect to the nearest node.|
-|ConnectToNearByPort|Enables to connect to the nearest port.|
-|Tooltip|Enables or disables tooltip for the connectors.|
-|LineRouting| Enables or disables routing to the connector.|
-|InheritLineRouting|Enables or disables routing to the connector. |
-|InheritTooltip|Enables or disables inherit tooltip option from the parent object
-|ConnectToNearByElement|Enables to connect to the nearest elements.|
-|InheritSegmentThumbShape|Enables or disables to inherit the value of segmentThumbShape.|
-|ReadOnly|Enables or disables readonly for the connector.|
-|Default|Enables all constraints for the connector.|
-
-
-The following code illustrates how to disable selection by using connector constraints.
+|None|Disables all connector constraints.|
+|Select|Enables connector selection capability.|
+|Delete|Enables connector deletion capability.|
+|Drag|Enables connector dragging functionality.|
+|DragSourceEnd|Enables dragging of the connector's source endpoint.|
+|DragTargetEnd|Enables dragging of the connector's target endpoint.|
+|DragSegmentThumb|Enables dragging of segment control points.|
+|Interaction|Enables general interaction capabilities for the connector.|
+|AllowDrop|Enables drop operations on the connector.|
+|Bridging|Enables bridging functionality for the connector.|
+|InheritBridging|Inherits bridging settings from parent objects.|
+|BridgeObstacle|Enables the connector to act as a bridge obstacle.|
+|PointerEvents|Enables pointer event handling for the connector.|
+|ConnectToNearByNode|Enables automatic connection to nearby nodes.|
+|ConnectToNearByPort|Enables automatic connection to nearby ports.|
+|Tooltip|Enables tooltip display for the connector.|
+|LineRouting|Enables line routing functionality for the connector.|
+|InheritLineRouting|Inherits line routing settings from parent objects.|
+|InheritTooltip|Inherits tooltip settings from parent objects.|
+|ConnectToNearByElement|Enables automatic connection to nearby elements.|
+|InheritSegmentThumbShape|Inherits segment thumb shape from parent objects.|
+|ReadOnly|Enables read-only mode for the connector.|
+|Default|Enables all default constraints for the connector.|
+
+The following code demonstrates how to disable selection using connector constraints:
```ts
let connectors: ConnectorModel[] = [{
@@ -323,7 +323,7 @@ root.render();
```
-The following example shows how to add Bridging constraint to the default constraints of connector.
+The following example shows how to add bridging constraint to the default connector constraints:
```ts
let connectors: ConnectorModel[] = [{
@@ -353,9 +353,9 @@ const root = ReactDOM.createRoot(document.getElementById('diagram'));
root.render();
```
-N> To visualize connector bridging, we need to inject ConnectorBridgin module.
+N> To visualize connector bridging, inject the ConnectorBridging module.
-The following code example shows how the tooltip can be enabled for the connector.
+The following example shows how to enable tooltip for connectors:
```ts
let connectors: ConnectorModel[] = [{
@@ -446,20 +446,20 @@ N>By default, the following constraints are enabled for the connector,
* InheritSegmentThumbShape
* Default
-## Port constraints
+## Port Constraints
-The constraints property of the Port allows you to enable or disable the following behaviors of port.
+Port constraints control the behavior and connection capabilities of ports attached to nodes.
| Constraints | Description |
| -------- | -------- |
-|None|Disable all port Constraints.|
-|Draw|Enables to create the connection when mouse hover on the port.|
-|Drag|Enables or disables port dragging|
-|InConnect|Enables or disables to connect only the target end of connector.|
-|OutConnect|Enables or disables to connect only the source end of connector.|
-|ToolTip|Enables or disables the Tooltip for the ports.|
-|InheritTooltip|Enables or disables the Tooltip for the ports.|
-|Default|Enables all constraints for the port.|
+|None|Disables all port constraints.|
+|Draw|Enables connection creation when hovering over the port.|
+|Drag|Enables port dragging functionality.|
+|InConnect|Enables incoming connections to the port only.|
+|OutConnect|Enables outgoing connections from the port only.|
+|ToolTip|Enables tooltip display for the port.|
+|InheritTooltip|Inherits tooltip settings from parent objects.|
+|Default|Enables all default constraints for the port.|
The following code illustrates how to disable creating connections with a port.
@@ -478,7 +478,7 @@ let nodes: NodeModel[] = [
];
```
-The following code example shows how to modify the port constraints to accept target connection alone.
+The following code example shows how to configure port constraints to accept only incoming connections:
```ts
let nodes: NodeModel[] = [
@@ -530,19 +530,19 @@ N> By default, the following constraints are enabled for the port,
* InConnect
* OutConnect
-## Annotation constraints
+## Annotation Constraints
-The constraints property of the Annotations allows you to enable or disable certain behaviors of annotation.
+Annotation constraints control the behavior and edit ability of text annotations on nodes and connectors.
| Constraints | Description |
| -------- | -------- |
-|ReadOnly|Enables or disables the ReadOnly Constraints,|
-|InheritReadOnly|Enables or disables to inherit the ReadOnly option from the parent object.|
-|Select|Enables or Disable select support for the annotation|
-|Drag|Enables or Disable drag support for the annotation|
-|Resize| Enables or Disable resize support for the annotation |
-|Rotate| Enables or Disable rotate support for the annotation|
-|Interaction|Enables interaction of annotation|
+|ReadOnly|Enables read-only mode for the annotation.|
+|InheritReadOnly|Inherits read-only settings from parent objects.|
+|Select|Enables selection capability for the annotation.|
+|Drag|Enables dragging functionality for the annotation.|
+|Resize|Enables resize capability for the annotation.|
+|Rotate|Enables rotation capability for the annotation.|
+|Interaction|Enables general interaction capabilities for the annotation.|
|None|Disables all constraints for the annotation.|
The read-only mode for the annotation is enabled by settings ReadOnly constraints to the annotation.
@@ -614,28 +614,28 @@ Refer sample below
For more details about annotation constraints, refer to [`AnnotationConstraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/annotationConstraints#AnnotationConstraints).
-## Selector constraints
+## Selector Constraints
-Selector visually represents the selected elements with certain editable thumbs. The visibility of the thumbs can be controlled with selector constraints. The part of selector is categorized as follows:
+Selector constraints control the visibility and behavior of selection handles and thumbs that appear when elements are selected.
| Constraints | Description |
| -------- | -------- |
-|None|Hides all the selector elements.|
-|ConnectorSourceThumb|Shows or hides the source thumb of the connector.|
-|ConnectorTargetThumb|Shows or hides the target thumb of the connector.|
-|ResizeSouthEast|Shows or hides the bottom right resize handle of the selector.|
-|ResizeSouthWest|Shows or hides the bottom left resize handle of the selector.|
-|ResizeNorthEast|Shows or hides the top right resize handle of the selector.|
-|ResizeNorthWest|Shows or hides the top left resize handle of the selector.|
-|ResizeEast|Shows or hides the middle right resize handle of the selector.|
-|ResizeWest|Shows or hides the middle left resize handle of the selector.|
-|ResizeSouth|Shows or hides the bottom center resize handle of the selector.|
-|ResizeNorth|Shows or hides the top center resize handle of the selector.|
-|Rotate|Shows or hides the rotate handle of the selector.|
-|UserHandle|Shows or hides the user handles of the selector.|
-|ToolTip| Shows or hides the default tooltip for the drag, resize, and rotate operation of nodes and connectors. |
-|ResizeAll|Shows or hides all resize handles of the selector.|
-|All|Shows all handles of the selector.|
+|None|Hides all selector elements.|
+|ConnectorSourceThumb|Shows or hides the connector's source thumb.|
+|ConnectorTargetThumb|Shows or hides the connector's target thumb.|
+|ResizeSouthEast|Shows or hides the bottom-right resize handle.|
+|ResizeSouthWest|Shows or hides the bottom-left resize handle.|
+|ResizeNorthEast|Shows or hides the top-right resize handle.|
+|ResizeNorthWest|Shows or hides the top-left resize handle.|
+|ResizeEast|Shows or hides the middle-right resize handle.|
+|ResizeWest|Shows or hides the middle-left resize handle.|
+|ResizeSouth|Shows or hides the bottom-center resize handle.|
+|ResizeNorth|Shows or hides the top-center resize handle.|
+|Rotate|Shows or hides the rotation handle.|
+|UserHandle|Shows or hides custom user handles.|
+|ToolTip|Shows or hides tooltips during drag, resize, and rotate operations.|
+|ResizeAll|Shows or hides all resize handles.|
+|All|Shows all available handles.|
The following code illustrates how to hide rotator.
@@ -719,32 +719,32 @@ Refer sample below
For more information about selector constraints, refer to [`SelectorConstraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/selectorConstraints).
-N> By default, the following constraints are enabled for the selected items,
+N> By default, the following constraints are enabled for the selected items:
* Rotate
- * UserHandel
+ * UserHandle
* ResizeAll
* All
* ToolTip
-## Snap constraints
+## Snap Constraints
-Snap constraints control the visibility of gridlines and enable/disable snapping.
+Snap constraints control the visibility of gridlines and enable or disable snapping functionality for precise element positioning.
The following list of snapping constraints are used to enable or disable certain features of snapping.
| Constraints | Description |
| -------- | -------- |
-|None|Disable snapping for the nodes/connectors in diagram.|
-|ShowHorizontalLines|Displays only the horizontal gridlines in diagram.|
-|ShowVerticalLines|Displays only the Vertical gridlines in diagram.|
-|ShowLines|Display both Horizontal and Vertical gridlines.|
-|SnapToHorizontalLines|Enables the object to snap only with horizontal gridlines.|
-|SnapToVerticalLines|Enables the object to snap only with Vertical gridlines.|
-|SnapToLines|Enables the object to snap with both horizontal and Vertical gridlines.|
-|SnapToObject|Enables the object to snap with the other objects in the diagram.|
-|All|Shows gridlines and enables snapping.|
-
-The following code illustrates how to show only horizontal gridlines.
+|None|Disables snapping for all diagram elements.|
+|ShowHorizontalLines|Displays horizontal gridlines in the diagram.|
+|ShowVerticalLines|Displays vertical gridlines in the diagram.|
+|ShowLines|Displays both horizontal and vertical gridlines.|
+|SnapToHorizontalLines|Enables snapping to horizontal gridlines only.|
+|SnapToVerticalLines|Enables snapping to vertical gridlines only.|
+|SnapToLines|Enables snapping to both horizontal and vertical gridlines.|
+|SnapToObject|Enables snapping to other objects in the diagram.|
+|All|Shows gridlines and enables all snapping functionality.|
+
+The following code demonstrates how to show only horizontal gridlines:
{% raw %}
@@ -803,7 +803,7 @@ Refer sample below
For more information about snap constraints, refer to [`SnapConstraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/snapConstraints).
-N> By default, the following constraints are enabled for the snap functionality in the diagram,
+N> By default, the following constraints are enabled for the snap functionality:
* ShowLines
* ShowVerticalLines
* ShowHorizontalLines
@@ -813,17 +813,16 @@ N> By default, the following constraints are enabled for the snap functionality
* SnapToObject
* All
-## Boundary constraints
-
-Boundary constraints defines a boundary for the diagram inside which the interaction should be done.
+## Boundary Constraints
+Boundary constraints define the interaction boundaries for diagram elements, controlling where users can perform operations.
The following list of constraints are used to enable or disable certain features of boundary interactions of the diagram.
| Constraints | Description |
| -------- | -------- |
-|Infinity|Allow the interactions to take place at the infinite height and width.|
-|Diagram|Allow the interactions to take place around the diagram height and width.|
-|Page|Allow the interactions to take place around the page height and width.|
+|Infinity|Allows interactions at infinite height and width.|
+|Diagram|Limits interactions within the diagram's height and width.|
+|Page|Limits interactions within the page boundaries.|
The following code illustrates how to limit the interaction done inside a diagram within a page.
@@ -860,13 +859,13 @@ Refer sample below
{% previewsample "page.domainurl/code-snippet/diagram/constraints/constraints-cs7" %}
-For more information about selector constraints, refer to [`BoundaryConstraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/boundaryConstraints).
+For more information about boundary constraints, refer to [`BoundaryConstraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/boundaryConstraints).
-## Inherit behaviors
+## Inherit Behaviors
-Some of the behaviors can be defined through both the specific object (node/connector) and diagram. When the behaviors are contradictorily defined through both, the actual behavior is set through inherit options.
+When behaviors are defined at both the specific object level (node/connector) and diagram level, inheritance options determine the actual behavior applied.
-The following code example illustrates how to inherit the line bridging behavior from the diagram model.
+The following code example demonstrates how to inherit line bridging behavior from the diagram model:
```ts
let connectors: ConnectorModel[] = [{
@@ -901,36 +900,36 @@ const root = ReactDOM.createRoot(document.getElementById('diagram'));
root.render();
```
-## Bitwise operations
+## Bitwise Operations
-Bitwise operations are used to manipulate the flagged enumerations [enum]. In this section, Bitwise operations are illustrated by using node constraints. The same is applicable while working with node constraints, connector constraints, or port constraints.
+Bitwise operations manipulate flagged enumerations to enable precise control over multiple constraint behaviors simultaneously.
-## Add operation
+### Add Operation
-You can add or enable multiple values at a time by using Bitwise ‘|’ (OR) operator.
+Use the Bitwise `|` (OR) operator to add or enable multiple values:
```ts
node.constraints = NodeConstraints.Select | NodeConstraints.Rotate;
```
-In the previous example, you can do both the selection and rotation operation.
+This example enables both selection and rotation operations for the node.
-## Remove Operation
+### Remove Operation
-You can remove or disable values by using Bitwise ‘&~’ (XOR) operator.
+Use the Bitwise `&~` (XOR) operator to remove or disable specific values:
```ts
node.constraints = node.constraints & ~NodeConstraints.Rotate;
```
-In the previous example, rotation is disabled but other constraints are enabled.
+This example disables rotation while maintaining other enabled constraints.
-## Check operation
+### Check Operation
-You can check any value by using Bitwise ‘&’ (AND) operator.
+Use the Bitwise `&` (AND) operator to verify if specific values are enabled:
```ts
if ((node.constraints & NodeConstraints.Rotate) == NodeConstraints.Rotate);
```
-In the previous example, check whether the rotate constraints are enabled in a node. When node constraints have rotate constraints, the expression returns a rotate constraint.
+This example checks whether rotation constraints are enabled for a node. When the node has rotation constraints enabled, the expression returns the rotate constraint value.
\ No newline at end of file
diff --git a/ej2-react/diagram/container.md b/ej2-react/diagram/container.md
index 07c5454c8..e1bf07abc 100644
--- a/ej2-react/diagram/container.md
+++ b/ej2-react/diagram/container.md
@@ -1,22 +1,22 @@
---
layout: post
-title: Container in React Diagram component | Syncfusion®
-description: Learn here all about Container in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Container in React Diagram Component | Syncfusion®
+description: Learn here all about Container in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Container
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Container in React Diagram component
+# Container in React Diagram Component
-A Container is a group of logically related shapes surrounded by a visible boundary. Shapes can be added or removed from the container at runtime. Changes made to the container do not affect its child elements, which can be individually selected, moved, or edited.
+A Container is a specialized node that groups logically related shapes within a visible boundary. Unlike regular groups, containers automatically manage child elements while maintaining individual element properties. Common use cases include organizing related components in flowcharts, creating swimlanes in process diagrams, and building composite UI layouts.
## Create Container
### Add a Container
-The following code illustrates how to create a container node:
+Container nodes require specific configuration to enable child element management and boundary recognition. The following example demonstrates creating a basic container with essential properties:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -31,9 +31,9 @@ The following code illustrates how to create a container node:
### Setting a Header
-You can provide a textual description for a container using its [header](https://ej2.syncfusion.com/react/documentation/api/diagram/containerModel/#header) property. Also, users can customize the header's appearance using the header's [style](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel/#style) property.
+Headers provide textual identification for containers and can be fully customized for appearance and behavior. The [`header`](https://ej2.syncfusion.com/react/documentation/api/diagram/containerModel/#header) property accepts text content, while the header's [`style`](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel/#style) property controls visual formatting including fonts, colors, and alignment.
-The following code example explains how to define a container header and its customization:
+The following example shows header configuration with custom styling:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -46,17 +46,17 @@ The following code example explains how to define a container header and its cus
{% previewsample "page.domainurl/code-snippet/diagram/container/container-2" %}
-N> You can edit the header by double-clicking the region of the container's header.
+N> Double-click the header region to enable inline text editing functionality.
-### Container from symbol palette
+### Container from Symbol Palette
-Container nodes can be preconfigured and added to the symbol palette. Users can drag and drop these container nodes into the diagram as needed.
+Preconfigured container templates can be added to the symbol palette for reusable across diagrams. This approach standardizes container designs and accelerates diagram creation workflows.
-To learn more, refer to the [Symbol Palette](./symbol-palette) documentation.
+For detailed symbol palette integration steps, refer to the [Symbol Palette](./symbol-palette) documentation.
-## Interactively add or remove diagram elements into Container
+### Interactively Add or Remove Elements
-You can interactively add or remove diagram elements from the Container in the runtime. When a diagram element is dropped near the container's edge, the container automatically resizes to accommodate it.
+The diagram supports drag-and-drop operations for adding elements to containers at runtime. When elements approach a container's boundary, visual feedback indicates drop zones, and the container automatically expands to accommodate new children while maintaining proper spacing.

@@ -70,8 +70,8 @@ The events triggered when interacting with container nodes are similar to those
## See Also
-* [How to add nodes to the symbol palette](./symbol-palette)
-* [How to customize nodes](./nodes-customization)
-* [How to add ports to the node](./ports)
-* [How to enable/disable the behavior of the node](./constraints)
-* [How to create diagram nodes using drawing tools](./tools)
+* [How to add nodes to the symbol palette.](./symbol-palette)
+* [How to customize nodes.](./nodes-customization)
+* [How to add ports to the node.](./ports)
+* [How to enable/disable the behavior of the node.](./constraints)
+* [How to create diagram nodes using drawing tools.](./tools)
diff --git a/ej2-react/diagram/context-menu.md b/ej2-react/diagram/context-menu.md
index 4d0a3c419..f6aef88b9 100644
--- a/ej2-react/diagram/context-menu.md
+++ b/ej2-react/diagram/context-menu.md
@@ -1,29 +1,34 @@
---
layout: post
-title: Context menu in React Diagram component | Syncfusion®
-description: Learn here all about Context menu in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Context menu in React Diagram Component | Syncfusion®
+description: Learn here all about Context menu in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Context menu
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Context menu in React Diagram component
+# Context Menu in React Diagram Component
-In a graphical user interface (GUI), a context menu is a type of menu that appears when you perform a right-click operation. It offers users a set of actions relevant to the current context. In diagrams, context menus can be customized extensively. The Diagram control provides built-in context menu items while also allowing users to define custom menu items through the [`contextMenuSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/#contextmenusettings) property. This flexibility enables tailoring menus to specific application needs, including creating nested levels of menu items for more intricate user interactions. To ensure the context menu is rendered correctly, make sure to include the necessary CSS references from the Syncfusion® `ej2-navigations` package. This can be achieved by adding the following line in your `src/App.css` file.
+In graphical user interfaces, a context menu appears when you perform a right-click operation, offering users a set of actions relevant to the current context. The React Diagram component provides extensive context menu customization capabilities through the [`contextMenuSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/#contextmenusettings) property.
+
+The Diagram control includes built-in context menu items and allows you to define custom menu items. This flexibility enables you to tailor menus to specific application needs, including creating nested levels of menu items for complex user interactions.
+
+## Prerequisites
+
+To ensure the context menu renders correctly, include the necessary CSS references from the Syncfusion® `ej2-navigations` package by adding the following line to your `src/styles.css` file:
`@import "../node_modules/@syncfusion/ej2-navigations/styles/material.css";`
N> If you want to use contextMenu in diagram, you need to inject `DiagramContextMenu` Module in the diagram.
-## Default context menu
+## Default Context Menu
-Diagram provides some default context menu items to ease the execution of some frequently used commands. The [`show`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuSettings/#show) property helps you to enable/disable the context menu.
-
-The following code illustrates how to enable the default context menu items.
+The Diagram component provides default context menu items for frequently used commands. Use the [`show`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuSettings/#show) property to enable or disable the context menu.
+The following code demonstrates how to enable the default context menu items:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -36,22 +41,22 @@ The following code illustrates how to enable the default context menu items.
{% previewsample "page.domainurl/code-snippet/diagram/contextmenu/contextmenu-cs1" %}
-## Custom context menu
-
-Context menu can be defined for individual node with the desired context menu items.
+## Customize Context Menu
-Context menus can be customized for individual nodes by defining specific menu items beyond the default options. To add additional context menu items, you need to define and incorporate them into the [`items`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuSettings/#items) property of the context menu.
+You can customize context menus for individual nodes by defining specific menu items beyond the default options. To add custom context menu items, define and incorporate them into the [`items`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuSettings/#items) property of the context menu.
Each custom item can be defined with specific text and ID using the[`text`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuItemModel/#items) and [`ID`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuItemModel/#id) properties, respectively. Additionally, you can enhance visual cues by associating icons through the [`iconCss`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuItemModel/#iconcss) for enabling the use of font icons. The [`target`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuItemModel/#target) property specifies where each menu item should appear, and separators can be included using the [`separator`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuItemModel/#separator) property to visually group menu items. This flexibility allows for a tailored user interface that meets specific application needs efficiently. Nested menu items are defined within the [`items`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuItemModel/#items) property of a parent menu item.
-### To Display custom menu alone
+### Display Custom Menu Only
+
+To display only custom context menu items, set the [`showCustomMenuOnly`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuSettingsModel/#showcustommenuonly) property to **true**.
-To display the custom context menu items alone, set the [`showCustomMenuOnly`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuSettingsModel/#showcustommenuonly) property to true.
+### Context Menu Click
-### Context menu click
+Handle custom menu item actions using the [`contextMenuClick`](https://ej2.syncfusion.com/react/documentation/api/diagram/#contextmenuclick) event. This event triggers when a menu item is clicked and allows you to define specific actions based on the selected item.
-Upon clicking custom menu items, actions are handled using the [`contextMenuClick`](https://ej2.syncfusion.com/react/documentation/api/diagram/#contextmenuclick) event in the diagram. This event allows you to define actions based on which menu item is clicked. For instance, in the example below, the cloning of nodes and the change of fill color for nodes and annotations are efficiently managed and implemented through this event.
+The following example demonstrates context menu click handling for node cloning and color changes:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -65,11 +70,11 @@ Upon clicking custom menu items, actions are handled using the [`contextMenuClic
{% previewsample "page.domainurl/code-snippet/diagram/contextmenu/contextmenu-cs2" %}
-### Context menu open
+### Context Menu Open
-In certain situations, you may want to hide specific menu items based on the selected elements in the diagram. This can be achieved using the [`contextMenuOpen`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramBeforeMenuOpenEventArgs/) event. When the context menu is opened via right-click, the `contextMenuOpen` event is triggered. Within this event, you can create an array of menu items to hide for the selected element and pass it to the [`hiddenItems`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramBeforeMenuOpenEventArgs/#hiddenitems) property of the contextMenuOpen event argument.
+In certain situations, you may want to hide specific menu items based on the selected elements in the diagram. This can be achieved using the [`contextMenuOpen`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramBeforeMenuOpenEventArgs/) event. When the context menu opens via right-click, this event triggers and allows you to create an array of menu items to hide for the selected element. Pass this array to the[`hiddenItems`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramBeforeMenuOpenEventArgs/#hiddenitems) property of the contextMenuOpen event argument.
-The following example demonstrates how to display different custom menu items for nodes, connectors, and the diagram based on the selection.
+The following example shows how to display different custom menu items for nodes, connectors, and the diagram based on selection:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -82,9 +87,9 @@ The following example demonstrates how to display different custom menu items fo
{% previewsample "page.domainurl/code-snippet/diagram/contextmenu/contextmenu-cs3" %}
-### Context menu with Url
+### Context Menu with URL
-[`url`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuItemModel#url) property of the menu item is used to set the url of any website which will be opened upon clicking on them.
+Use the[`url`](https://ej2.syncfusion.com/react/documentation/api/diagram/contextMenuItemModel#url) property of menu items to set website URLs that open when clicked.
The following code example shows the context menu with url for three websites.
@@ -153,11 +158,11 @@ root.render();
```
{% endraw %}
-## Template Support for Context menu
+## Template Support for Context Menu
-Diagram provides template support for the context menu. The template for the context menu items can be customized before rendering by using the [`contextMenuBeforeItemRender`](https://ej2.syncfusion.com/react/documentation/api/diagram/#contextmenubeforeitemrender) event, which triggers while rendering each menu item.
+The Diagram component provides template support for context menu customization. Customize menu item templates before rendering using the [`contextMenuBeforeItemRender`](https://ej2.syncfusion.com/react/documentation/api/diagram/#contextmenubeforeitemrender) event, which triggers while rendering each menu item.
-In the following example, menu items are rendered with shortcut key codes for specific actions in the context menu using a template. The key codes for cut, copy, and paste actions are displayed at the right corner of the menu items by adding a span element in the `contextMenuBeforeItemRender` event.
+The following example renders menu items with shortcut key codes for specific actions. Key codes for cut, copy, and paste actions display in the right corner of menu items by adding a span element in the `contextMenuBeforeItemRender` event:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -170,7 +175,7 @@ In the following example, menu items are rendered with shortcut key codes for sp
{% previewsample "page.domainurl/code-snippet/diagram/contextmenu/es5menutemplate-cs1" %}
-## Context menu events
+## Context Menu Events
|Event|Description|
|----|----|
diff --git a/ej2-react/diagram/data-binding.md b/ej2-react/diagram/data-binding.md
index ffbea7a5b..140f76c17 100644
--- a/ej2-react/diagram/data-binding.md
+++ b/ej2-react/diagram/data-binding.md
@@ -1,18 +1,22 @@
---
layout: post
-title: Data binding in React Diagram component | Syncfusion®
-description: Learn here all about Data binding in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Data binding in React Diagram Component | Syncfusion®
+description: Learn here all about Data binding in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Data binding
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Data binding in React Diagram component
+# Data Binding in React Diagram Component
-* Diagram can be populated with the `nodes` and `connectors` based on the information provided from an external data source.
+The React Diagram component supports data binding to populate nodes and connectors from external data sources. This feature enables dynamic diagram creation based on structured data, making it ideal for visualizing organizational charts, flowcharts, and hierarchical data structures.
-* Diagram exposes its specific data-related properties allowing you to specify the data source fields from where the node information has to be retrieved from.
+Data binding in the Diagram component works by mapping data source fields to diagram elements through the `dataSourceSettings` property. The component supports both local JSON data and remote data sources, providing flexibility for various application scenarios.
+
+## Key Data Binding Properties
+
+The Diagram component exposes several data-related properties that control how data is mapped to diagram elements:
* The [`dataManager`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel#datamanager) property is used to define the data source either as a collection of objects or as an instance of `DataManager` that needs to be populated in the diagram.
@@ -24,16 +28,20 @@ domainurl: ##DomainURL##
* To explore those properties, see [`DataSourceSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel).
-* Diagram supports two types of data binding. They are:
+## Data Binding Types
+
+The Diagram component supports two primary data binding approaches:
- 1. Local data
- 2. Remote data
+1. **Local data binding** - Uses client-side JSON data.
+2. **Remote data binding** - Fetches data from server endpoints using DataManager.
-## Local data
+## Local Data Binding
-Diagram can be populated based on the user defined JSON data (Local Data) by mapping the relevant data source fields.
+Local data binding allows the diagram to render nodes and connectors based on client-side JSON data. This approach is ideal for static data or scenarios where the entire dataset is available on the client side.
-To map the user defined JSON data with diagram, configure the fields of [`dataSourceSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel). The following code example illustrates how to bind local data with the diagram.
+To implement local data binding, configure the [`dataSourceSettings`]fields to map your JSON data structure to diagram elements.
+
+The following code example illustrates how to bind local data with the diagram.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -46,15 +54,13 @@ To map the user defined JSON data with diagram, configure the fields of [`dataSo
{% previewsample "page.domainurl/code-snippet/diagram/dataBinding/es5LocalBinding-cs1" %}
-## Remote data
-
-You can bind the diagram with remote data by using [`dataManager`].
+## Remote Data Binding
-It uses two different classes: `DataManager` for processing and `Query` for serving data. `DataManager` communicates with data source and `Query` generates data queries that are read by the [`dataManager`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel).
+Remote data binding enables the diagram to fetch data from server endpoints using the DataManager service. This approach is suitable for large datasets, real-time data, or when data needs to be retrieved from databases or web services.
-To learn more about data manager, refer to [`Data Manager`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel).
+The DataManager handles data communication, while Query objects generate the requests that DataManager processes. This architecture provides powerful data manipulation capabilities including filtering, sorting, and paging.
-To bind remote data to the diagram,configure the fields of [`dataSourceSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel). The following code illustrates how to bind remote data to the diagram.
+For comprehensive DataManager information, see the `dataSourceSettings`. The following code illustrates how to bind remote data to the diagram.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -67,35 +73,37 @@ To bind remote data to the diagram,configure the fields of [`dataSourceSettings`
{% previewsample "page.domainurl/code-snippet/diagram/dataBinding/es5RemoteBinding-cs1" %}
-## CRUD
+## CRUD operations with Data Binding
-This feature allows you to read the data source and perform add or edit or delete the data in data source at runtime.
+The Diagram component supports Create, Read, Update, and Delete (CRUD) operations, allowing real-time synchronization between the diagram and its data source. This functionality enables users to modify diagram elements and persist changes to the backend.
-## Read DataSource
+### Reading Data from Multiple Sources
-* This feature allows you to define the nodes and connectors collection in the data source and connectionDataSource respectively.
+The diagram can simultaneously read from two data sources: one for nodes and another for connectors. This separation provides greater flexibility when dealing with complex data relationships.
-* You can set the data collection in the model’s dataSourceSettings [`dataSource`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel#datasource) property. The nodes will be generated based on the data specified in the data source.
+**Node Data Source Configuration:**
-* You can set the connector collection in the model’s dataSourceSettings [`connectionDataSource`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel#connectiondatasource) property.
+* Set the [`dataSource`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel#datasource) property to define the node data collection
-* The dataSourceSettings connectionDataSource [`dataManager`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#datamanager) property is used to set the data source for the connection data source items.
+*Use the [`id`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel#id) property to specify the unique identifier field
-* If you have a data (data will be set in the dataSource property) with parent relationship in the database and also defined the connector in the connectionDataSource simultaneously, then the connectors set in the connectionDataSource will be considered as a priority to render the connector.
+**Connector Data Source Configuration:**
-* The dataSourceSettings [`crudAction’s`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel#crudaction) [`read`](https://ej2.syncfusion.com/react/documentation/api/diagram/crudActionModel#read) property specifies the method, which is used to read the data source and its populate the nodes in the diagram.
+* Configure the [`connectionDataSource`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel#connectiondatasource) property for connector data.
-* The connectionDataSource crudAction’s [`read`](https://ej2.syncfusion.com/react/documentation/api/diagram/crudActionModel#read) specifies the method, which is used to read the data source and its populates the connectors in the diagram.
+* Set [`sourceID`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#sourceid) and [`targetID`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#targetid) to establish connections.
-* The dataSourceSettings’s [`id`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel#id) and connectionDataSource’s [`id`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#id) properties are used to define the unique field of each JSON data.
+* Define connection points using [`sourcePointX`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#sourcepointx), [`sourcePointY`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#sourcepointy), [`targetPointX`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#targetpointx), and [`targetPointY`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#targetpointy)
-* The connectionDataSource’s [`sourceID`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#sourceid) and [`targetID`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#targetid) properties are used to set the sourceID and targetID for connection data source item.
+* The dataSourceSettings connectionDataSource [`dataManager`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#datamanager) property is used to set the data source for the connection data source items.
-* The connectionDataSource’s [`sourcePointX`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#sourcepointx), [`sourcePointY`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#sourcepointy), [`targetPointX`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#targetpointx), and [`targetPointY`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectionDataSourceModel#targetpointy) properties are used to define the sourcePoint and targetPoint values for connector from data source.
+**Priority handling:** When both parent-child relationships in the main data source and explicit connectors in the connectionDataSource are defined, the explicit connectors take priority for rendering.
+
+* The dataSourceSettings [`crudAction’s`](https://ej2.syncfusion.com/react/documentation/api/diagram/dataSourceModel#crudaction) [`read`](https://ej2.syncfusion.com/react/documentation/api/diagram/crudActionModel#read) property specifies the method, which is used to read the data source and its populate the nodes in the diagram.
-* The dataSourceSettings crudAction’s [`customFields`](https://ej2.syncfusion.com/react/documentation/api/diagram/crudActionModel#customfields) property is used to maintain the additional information for nodes.
+* The connectionDataSource crudAction’s `read` specifies the method, which is used to read the data source and its populates the connectors in the diagram.
-* Similarly, connectionDataSource’s crudAction’s [`customFields`](https://ej2.syncfusion.com/react/documentation/api/diagram/crudActionModel#customfields) is used to maintain the additional information for connectors.
+**Custom fields:** Use the [`customFields`](https://ej2.syncfusion.com/react/documentation/api/diagram/crudActionModel#customfields) property in crudAction to maintain additional information for both nodes and connectors.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -108,17 +116,17 @@ This feature allows you to read the data source and perform add or edit or delet
{% previewsample "page.domainurl/code-snippet/diagram/dataBinding/es5connectionDataSource-cs1" %}
-## How to perform Editing at runtime
+### How to Perform Editing at Runtime
* The dataSourceSettings crudAction object allows you to define the method, which is used to get the changes done in the data source defined for shapes from the client-side to the server-side.
* Similarly, the connectionDataSource crudAction object allows you to define the method, which is used to get the changes done in the data source defined for connectors from the client-side to the server-side.
-## InsertData
+#### Creating New Data (InsertData)
* The dataSourceSettings crudAction’s [`create`](https://ej2.syncfusion.com/react/documentation/api/diagram/crudActionModel#create) property specifies the method, which is used to get the nodes added from the client-side to the server-side.
-* The connectionDataSource crudAction’s [`create`](https://ej2.syncfusion.com/react/documentation/api/diagram/crudActionModel#create) specifies the method, which is used to get the connectors added from the client-side to the server-side.
+* The connectionDataSource crudAction’s `create` specifies the method, which is used to get the connectors added from the client-side to the server-side.
* The following code example illustrates how to send the newly added or inserted data from the client to server-side.
@@ -174,7 +182,7 @@ diagramInstance.insertData();
* The dataSourceSettings crudAction’s [`update`](https://ej2.syncfusion.com/react/documentation/api/diagram/crudActionModel#update) property specifies the method, which is used to get the modified nodes from the client-side to the server-side.
-* The connectionDataSource crudAction’s [`update`](https://ej2.syncfusion.com/react/documentation/api/diagram/crudActionModel#update) specifies the method, which is used to get the modified connectors from the client-side to the server-side.
+* The connectionDataSource crudAction’s `update` specifies the method, which is used to get the modified connectors from the client-side to the server-side.
* The following code example illustrates how to send the updated data from the client to the server side.
@@ -230,7 +238,7 @@ diagramInstance.updateData();
* The dataSourceSettings crudAction’s [`destroy`](https://ej2.syncfusion.com/react/documentation/api/diagram/crudActionModel#destroy) property specifies the method, which is used to get the deleted nodes from the client-side to the server-side.
-* The connectionDataSource crudAction’s [`destroy`](https://ej2.syncfusion.com/react/documentation/api/diagram/crudActionModel#destroy) specifies the method, which is used to get the deleted connectors from the client-side to the server-side.
+* The connectionDataSource crudAction’s `destroy` specifies the method, which is used to get the deleted connectors from the client-side to the server-side.
{% raw %}
diff --git a/ej2-react/diagram/export.md b/ej2-react/diagram/export.md
index bd302f9ff..92312d06c 100644
--- a/ej2-react/diagram/export.md
+++ b/ej2-react/diagram/export.md
@@ -1,18 +1,22 @@
---
layout: post
-title: Export in React Diagram component | Syncfusion®
-description: Learn here all about Export in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Export in React Diagram Component | Syncfusion®
+description: Learn here all about Export in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Export
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Export in React Diagram component
+# Export in React Diagram Component
-Diagram provides support to export its content as image/svg files. The [`exportDiagram`](https://ej2.syncfusion.com/react/documentation/api/diagram/#exportdiagram) method of diagram helps to export the diagram. The following code illustrates how to export the diagram as image.
+The React Diagram component provides comprehensive support for exporting diagram content as image files (JPG, PNG) or vector graphics (SVG). This functionality enables users to save diagrams for documentation, presentations, or further processing. The [`exportDiagram`](https://ej2.syncfusion.com/react/documentation/api/diagram/#exportdiagram) method serves as the primary interface for all export operations.
->Note: To Export diagram, you need to inject `PrintAndExport` in the diagram.
+>Note: To export diagrams, inject `PrintAndExport` in the diagram component.
+
+## Basic Export Example
+
+The following code demonstrates a simple diagram export operation:
@@ -42,37 +46,38 @@ To export the React Diagram elements in various formats, refer to below video li
{% youtube "https://www.youtube.com/watch?v=IkWXjhRE-o0" %}
-## Exporting options
+## Export Configuration Options
-The diagram provides support to export the desired region of the diagram to various formats. The following table shows the list of [`exportOptions`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/) in diagram.
+The diagram component supports extensive customization through the [`exportOptions`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/) interface. The following table details all available configuration properties:
| Name | Type | Description|
|-------- | -------- | -------- |
-| bounds | object | Sets the bounds that has to be exported |
-| region | enum | Sets the region of the diagram to be exported. |
-| fileName | string | Sets the file name of the exported image. |
-| format | string | Sets the export image format. |
-| mode | string | Sets the Mode for the file to be downloaded. |
-| margin | object | Sets the margin of the page to be exported. |
-| stretch| enum | Sets the aspect ratio of the exported image.|
-| multiplePage | boolean | exports the diagram into multiple pages. |
-| pageWidth | number | Sets the page width of the diagram while exporting the diagram into multiple pages. |
-| pageHeight| number | Sets the page height of the diagram while exporting the diagram into multiple pages.|
-| pageOrientation | enum | Sets the orientation of the page. |
+| bounds | object | Defines specific bounds for CustomBounds region export |
+| region | enum | Specifies the diagram area to export (PageSettings, Content, or CustomBounds) |
+| fileName | string | Sets the exported file name (default: "Diagram") |
+| format | string | Defines export format (JPG, PNG, or SVG) |
+| mode | string | Controls export behavior (Download or Data) |
+| margin | object | Adds spacing around the exported content |
+| stretch| enum | Adjusts aspect ratio and image quality of exported content |
+| multiplePage | boolean | Enables multi-page export for large diagrams |
+| pageWidth | number | Sets page width for multi-page exports |
+| pageHeight| number | Sets page height for multi-page exports |
+| pageOrientation | enum | Controls page orientation (Portrait or Landscape) |
+## File Name Configuration
-### File Name
+[`FileName`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#filename) property specifies the name for downloaded files. When not specified, the default name **Diagram** is used.
-[`FileName`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#filename) is the name of the file to be downloaded. By default, the file name is set to **Diagram**.
+## Export Formats
-### Format
+The [`Format`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#format) property determines the output file type. The component supports three formats with distinct characteristics:
-[`Format`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#format) specifies the type/format of the exported file. By default, the diagram is exported in .jpg format. You can export the diagram to the following formats:
+* **JPG**: Compressed format suitable for photographs and complex diagrams with many colors.
+* **PNG**: Lossless format ideal for diagrams with transparency or sharp edges.
+* **SVG**: Vector format that maintains quality at any scale and supports text selection.
-* JPG
-* PNG
-* SVG
+The default export format is JPG. The following example shows format specification:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -86,12 +91,9 @@ The diagram provides support to export the desired region of the diagram to vari
{% previewsample "page.domainurl/code-snippet/diagram/export/export-cs1" %}
+## Margin Configuration
-### Margin
-
-The [`margin`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#margin) specifies the amount of space that has to be left around the diagram while exporting.
-
-The following code example demonstrates how to set margin for the exported image.
+The [`margin`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#margin) property adds whitespace around the exported diagram content. This spacing improves presentation and prevents content from appearing cramped.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -105,12 +107,14 @@ The following code example demonstrates how to set margin for the exported image
{% previewsample "page.domainurl/code-snippet/diagram/export/export-cs2" %}
-### Mode
+## Export Modes
+
+The [`mode`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#mode) property controls how the exported content is delivered:
-The [`mode`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#mode) option specifies whether to export the diagram as an image or to return the base64 data of the diagram. The available export modes are:
+* **Download**: Automatically downloads the diagram as a file to the user's device.
+* **Data**: Returns a base64 string representation for programmatic processing.
-* Download: Exports and downloads the diagram as an image or SVG file.
-* Data: Returns a base64 string representation of the diagram.
+The Data mode is useful for applications that need to process or transmit the exported content programmatically:
The following code example demonstrates how to export the diagram as raw data.
@@ -142,17 +146,17 @@ root.render();
```
-### Region
+## Region-Based Export
Exporting particular region of diagram is possible by using the [`region`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#region) property of the [`exportOptions`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/). The available export regions are listed in the table below.
| Region | Description |
|-------- | -------- |
-| PageSettings | The region to be exported will be based on the given page settings |
-| Content | Only the content of the diagram control will be exported |
-| CustomBounds | The region to be exported will be explicitly defined |
+| PageSettings | Exports based on the configured page dimensions and settings. |
+| Content | Exports only the visible diagram elements, excluding empty space. |
+| CustomBounds | Exports a user-defined rectangular area. |
-The following example shows how to export diagram with different regions.
+The following example demonstrates different region export options:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -166,13 +170,16 @@ The following example shows how to export diagram with different regions.
{% previewsample "page.domainurl/code-snippet/diagram/export/export-cs3" %}
->Note: The [`bounds`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#bounds) property of [`exportOptions`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/) should be defined to export the diagram with CustomBounds region.
+>Note: The [`bounds`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#bounds) property of `exportOptions` should be defined to export the diagram with CustomBounds region.
+
+## Multi-Page Export
-### MultiplePage
+For large diagrams that exceed standard page dimensions, the [`multiplePage`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#multiplepage) option enables export across multiple pages:
-When the [`multiplePage`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#multiplepage) option is set to false, the diagram is exported as a single image. When it set to true, the diagram is exported as multiple images based on its width and height.
+* **false** (default): Export as a single image regardless of size
+* **true**: Split the diagram across multiple pages based on specified dimensions
-The following code example demonstrates how to export the diagram as multiple images.
+The following example shows multi-page export configuration:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -186,9 +193,9 @@ The following code example demonstrates how to export the diagram as multiple im
{% previewsample "page.domainurl/code-snippet/diagram/export/export-cs4" %}
-### Export image
+## Direct Image Export
-You can pass the base64 data of an image to the [`exportImage`](https://ej2.syncfusion.com/react/documentation/api/diagram/#exportimage) method to export it directly. The following example shows how to export base64 data using the `exportImage` method.
+The [`exportImage`](https://ej2.syncfusion.com/react/documentation/api/diagram/#exportimage) method allows direct export of base64 image data without requiring a diagram instance. This method is useful for processing pre-existing image data.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -202,9 +209,9 @@ You can pass the base64 data of an image to the [`exportImage`](https://ej2.sync
{% previewsample "page.domainurl/code-snippet/diagram/export/export-cs5" %}
-### Get diagram content
+## Diagram Content Retrieval
-To get the html diagram content, the [`getDiagramContent`](https://ej2.syncfusion.com/react/documentation/api/diagram/#getdiagramcontent) method is used. the following example shows how to get the diagram content at runtime.
+The [`getDiagramContent`](https://ej2.syncfusion.com/react/documentation/api/diagram/#getdiagramcontent) method retrieves the HTML representation of the diagram at runtime. This functionality supports dynamic content analysis and processing.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -218,9 +225,9 @@ To get the html diagram content, the [`getDiagramContent`](https://ej2.syncfusio
{% previewsample "page.domainurl/code-snippet/diagram/export/export-cs6" %}
-### Export diagram with stretch option
+## Stretch Option for Enhanced Quality
-Diagram provides support to export the diagram as image for [`stretch`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#stretch) option. The exported images will be clearer but larger in file size.
+The [`stretch`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExportOptions/#stretch) property improves exported image quality by adjusting the aspect ratio. Images exported with stretch enabled are clearer but result in larger file sizes.
The following code example illustrates how to export the region occupied by the diagram elements.
@@ -253,6 +260,6 @@ root.render();
```
-## Limitations
+## Export Limitations
Currently, exporting diagram into image format with native and HTML nodes is not supported. To overcome this limitation, we make use of the Syncfusion® Essential® PDF library. This library incorporates the Syncfusion® Essential® HTML converter, which employs the advanced Blink rendering engine. This converter seamlessly transforms HTML content into images. Refer to [`export Html-and-Native node`](https://support.syncfusion.com/kb/article/15530/how-to-print-or-export-the-html-and-native-node-into-image-format-using-react-diagram) kb for more information.
diff --git a/ej2-react/diagram/flowchart-layout.md b/ej2-react/diagram/flowchart-layout.md
index d5133d6f4..2d90d4583 100644
--- a/ej2-react/diagram/flowchart-layout.md
+++ b/ej2-react/diagram/flowchart-layout.md
@@ -1,57 +1,56 @@
---
layout: post
-title: Flowchart layout in React Diagram component | Syncfusion®
-description: Learn here all about Flowchart layout in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Flowchart layout in React Diagram Component | Syncfusion®
+description: Learn here all about Flowchart layout in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Flowchart layout
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Flowchart layout in React Diagram control
+# Flowchart Layout in React Diagram Component
The flowchart layout provides a visual representation of processes, workflows, systems, or algorithms in a diagrammatic format. It uses various symbols to depict different actions, with arrows connecting these symbols to indicate the flow or direction of the process. Flowcharts are Essential® tools for illustrating step-by-step sequences, making complex processes easier to understand and communicate.
-## Common flowchart symbols
+## Common Flowchart Symbols
-Different flowchart symbols have different meanings that are used to represent different states in flowchart. The following table describes the most common flowchart symbols that are used in creating flowchart.
+Different flowchart symbols have specific meanings used to represent various states and actions in flowcharts. The following table describes the most common flowchart symbols used when creating flowcharts.
|Symbol|Shape name|Description|
|---|---|---|
-||Terminator|Indicates the beginning and ending of the process.|
-||Data|Indicates data input or output for a process.|
-||Process|Represents an operation or set of operations and data manipulations.|
-||Decision|Shows a branching point where the decision is made to choose one of the two paths|
-||Document|Represents a single document or report in the process.|
-||PreDefinedProcess|Represents a sequence of actions that combine to perform a specific task that is defined elsewhere.|
-||StoredData|Represents a step where data get stored within a process.|
-||InternalStorage|Represents the internal storage|
-||DirectData|Represents a collection of information that allows searching, sorting, and filtering.|
-||SequentialData|Represents the data that must be accessed sequentially|
-||Sort|Represents a step that organizes items list sequentially|
-||PaperTap|Represents a step where data get stored within a process.|
-||ManualInput|Represents the manual input of data into a field or step in a process.|
-||ManualOperation|Represents an operation in a process that must be done manually, not automatically.|
-||Preparation|Represents a setup or initialization process to another step in the process.|
-||OffPageReference|Represents a labeled connector used to link two flowcharts on different pages.|
-||MultiDocument|Represents multiple documents or reports in the process.|
-||Card|Represents a data card or punched card used for data entry or storage |
-||SummingJunction|Represents the logical AND (merge multiple inputs into a single output). |
-||Or|Represents the logical OR|
-||Merge|Represents a step where two or more sub-lists or sub-processes become one.|
-||Extract|Represents retrieving or obtaining data from a source for further processing or analysis in a flowchart.|
-||Delay|Represents the period of delay in a process|
-||Collate|Represents the process of gathering and arranging data or documents from multiple sources into a structured format.|
-||Annotation|Represents additional information, clarifications, about a process or decision point in the flowchart.|
-||Annotation2|Represents additional information, or comments about a process in the flowchart.|
-||SequentialAccessStorage|Represents information that is stored in a sequence.|
-||Display|Represents that the information, data, or output is being shown on a screen or printed for the user’s review.|
-||LoopLimit|Represents a maximum number of times a particular process or operation can be repeated within a loop.|
-||Connector|Represents a direction of flow from one step to another. It will get created automatically based on the relationship between the parent and child.|
-
-## Render Flowchart layout with data source
-
-To render `flowchart` layout, you need to set the [`layoutType`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#type) property as `Flowchart`. The following code example displays how to render flowchart layout using data source.
-
+||Terminator|Indicates the beginning and ending of the process.|
+||Data|Indicates data input or output for a process.|
+||Process|Represents an operation or set of operations and data manipulations.|
+||Decision|Shows a branching point where the decision is made to choose one of the two paths|
+||Document|Represents a single document or report in the process.|
+||PreDefinedProcess|Represents a sequence of actions that combine to perform a specific task that is defined elsewhere.|
+||StoredData|Represents a step where data get stored within a process.|
+||InternalStorage|Represents the internal storage|
+||DirectData|Represents a collection of information that allows searching, sorting, and filtering.|
+||SequentialData|Represents the data that must be accessed sequentially|
+||Sort|Represents a step that organizes items list sequentially|
+||PaperTap|Represents a step where data get stored within a process.|
+||ManualInput|Represents the manual input of data into a field or step in a process.|
+||ManualOperation|Represents an operation in a process that must be done manually, not automatically.|
+||Preparation|Represents a setup or initialization process to another step in the process.|
+||OffPageReference|Represents a labeled connector used to link two flowcharts on different pages.|
+||MultiDocument|Represents multiple documents or reports in the process.|
+||Card|Represents a data card or punched card used for data entry or storage |
+||SummingJunction|Represents the logical AND (merge multiple inputs into a single output). |
+||Or|Represents the logical OR|
+||Merge|Represents a step where two or more sub-lists or sub-processes become one.|
+||Extract|Represents retrieving or obtaining data from a source for further processing or analysis in a flowchart.|
+||Delay|Represents the period of delay in a process|
+||Collate|Represents the process of gathering and arranging data or documents from multiple sources into a structured format.|
+||Annotation|Represents additional information, clarifications, about a process or decision point in the flowchart.|
+||Annotation2|Represents additional information, or comments about a process in the flowchart.|
+||SequentialAccessStorage|Represents information that is stored in a sequence.|
+||Display|Represents that the information, data, or output is being shown on a screen or printed for the user’s review.|
+||LoopLimit|Represents a maximum number of times a particular process or operation can be repeated within a loop.|
+||Connector|Represents a direction of flow from one step to another. It will get created automatically based on the relationship between the parent and child.|
+
+## Render Flowchart layout with Data Source
+
+To render a flowchart layout, set the [`layoutType`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#type) property to **Flowchart**. The following code example demonstrates how to render a flowchart layout using a data source.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -70,9 +69,9 @@ To render `flowchart` layout, you need to set the [`layoutType`](https://ej2.syn
>Note: If you want to convert the data source into flowchart layout, you need to inject DataBinding along with FlowchartLayout module in the diagram.
-## Defining data source with appearance configuration
+## Configuring Data Source with Appearance Settings
-In the flowchart layout, you can define the desired shape, style, and label for each node, as well as the decorator type for connectors, directly within the data source. The data source should be structured as shown in the example below:
+In the flowchart layout, you can define the desired shape, style, and label for each node, as well as the decorator type for connectors, directly within the data source. Structure the data source as shown in the example below:
```javascript
var Data = [
@@ -103,21 +102,22 @@ In the flowchart layout, you can define the desired shape, style, and label for
```
-### Field Definitions
-- `name`: Represents the annotation displayed on the node.
-- `shape`: Defines the shape of the node (e.g., Terminator, Process).
-- `color`: Specifies the fill color of the node.
-- `stroke`: Defines the border color of the node.
-- `strokeWidth`: Specifies the border thickness of the node.
-- `label`: Adds annotations to the incomming connectors.
-- `arrowType`: Determines the arrowhead type (decorator) of the incoming connector (e.g., Diamond, Fletch).
+### Data Source Field Definitions
+
+- **`name`**: Text annotation displayed on the node.
+- **`shape`**: Node shape type (e.g., Terminator, Process, Decision).
+- **`color`**: Fill color for the node background.
+- **`stroke`**: Border color of the node.
+- **`strokeWidth`**: Border thickness in pixels.
+- **`label`**: Annotations for incoming connectors.
+- **`arrowType`**: Arrowhead type for incoming connectors (e.g., Diamond, Fletch).
-This structure allows for easy customization of the flowchart's visual elements based on the provided data source.
+This structure enables comprehensive customization of the flowchart's visual elements based on the provided data source.
-## Render Flowchart layout with nodes and connectors
+## Render Flowchart Layout with Nodes and Connectors
-The following example demonstrates how to render a flowchart layout using nodes and connectors. To achieve this, you need to define the [`nodes`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeModel/) and [`connectors`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectormodel/) collections and assign them to the diagram. Additionally, you need to set the [`layoutType`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#type) to `Flowchart`.
+The following example demonstrates how to render a flowchart layout using nodes and connectors. To achieve this, you need to define the [`nodes`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeModel/) and [`connectors`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectormodel/) collections and assign them to the diagram. Additionally, you need to set the `layoutType` to **Flowchart**.
{% tabs %}
@@ -132,14 +132,14 @@ The following example demonstrates how to render a flowchart layout using nodes
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/flowchart-cs2" %}
-## Customize flowchart layout orientation
+## Customize Flowchart Layout Orientation
-The sequence of a node's direction can be customized by flowchart's orientation, either vertically from top to bottom or horizontally from left to right. The [orientation](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#orientation) property of the layout class allows you to define the flow direction for the flowchart as either `TopToBottom` or `LeftToRight`. The default orientation is `TopToBottom`.
+Customize the flow direction of the flowchart using the [orientation](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#orientation) property of the layout class. The flowchart can flow either vertically from top to bottom or horizontally from left to right. The default orientation is **TopToBottom**.
-### TopToBottom orientation
+### TopToBottom Orientation
-This orientation arranges elements in the layout vertically, flowing from top to bottom. It is commonly used in flowcharts to represent the sequential progression of steps or actions in a process.
+This orientation arranges elements vertically, flowing from top to bottom. It is commonly used in flowcharts to represent the sequential progression of steps or actions in a process.
```typescript
@@ -163,10 +163,10 @@ export class AppComponent {
```
-
+
-### LeftToRight orientation
+### LeftToRight Orientation
This orientation arranges elements in the layout horizontally, flowing from left to right. It is typically used to represent processes or workflows that move sequentially across the page, emphasizing a linear progression of steps or actions.
@@ -192,19 +192,20 @@ export class AppComponent {
```
-
+
-## Customize the decision output directions
+## Customize the Decision Output Directions
The decision symbol in a flowchart represents a question or condition that leads to different paths based on a binary outcome (Yes/No, True/False). You can customize the output direction of these paths using the [`yesBranchDirection`](https://ej2.syncfusion.com/react/documentation/api/diagram/branchDirection/) and [`noBranchDirection`](https://ej2.syncfusion.com/react/documentation/api/diagram/branchDirection/) properties of the [`flowchartLayoutSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/flowchartLayoutSettingsModel/) class.
-- `LeftInFlow` - Arranges the Yes/No branch to the left of the decision symbol.
-- `RightInFlow` - Arranges the Yes/No branch to the right of the decision symbol.
-- `SameAsFlow` - Aligns the Yes/No branch in the same direction as the flow of the decision symbol.
+### Branch Direction Options
-The following example shows flowchart layout with `yesBranchDirection` as `SameAsFlow` and `noBranchDirection` as `LeftInFlow`.
+- **`LeftInFlow`** - Arranges the Yes/No branch to the left of the decision symbol.
+- **`RightInFlow`** - Arranges the Yes/No branch to the right of the decision symbol.
+- **`SameAsFlow`** - Aligns the Yes/No branch in the same direction as the flow of the decision symbol.
+The following example shows a flowchart layout with `yesBranchDirection` set to `SameAsFlow` and `noBranchDirection` set to `LeftInFlow`.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -218,29 +219,34 @@ The following example shows flowchart layout with `yesBranchDirection` as `SameA
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/flowchart-cs3" %}
-The following table will explain the pictorial representation of the behavior:
+The following table illustrates the visual behavior of different branch direction combinations:
|YesBranchDirection| NoBranchDirection | TopToBottom | LeftToRight |
|---|---|---|---|
-| Left In Flow |Right In Flow|||
-| Right In Flow |Left In Flow || |
-| Same As Flow |Right In Flow || |
-| Same As Flow |Left In Flow || |
-| Right In Flow | Same As Flow || |
-| Left In Flow | Same As Flow || |
-|Same As Flow |Same As Flow|||
+| Left In Flow |Right In Flow|||
+| Right In Flow |Left In Flow || |
+| Same As Flow |Right In Flow || |
+| Same As Flow |Left In Flow || |
+| Right In Flow | Same As Flow || |
+| Left In Flow | Same As Flow || |
+|Same As Flow |Same As Flow|||
+
+>Note: When both branch directions are set to the same value, the **Yes** branch takes priority in positioning.
->Note: If both branch directions are same, **Yes** branch will be prioritized.
+## Custom Yes and No Branch Values
-## Custom Yes and No branch values
+The decision symbol produces two output branches: a Yes branch and a No branch. Configure custom text values to determine branch classification using the `yesBranchValues` property of the `flowchartLayoutSettings` class, it will be considered a Yes branch. Similarly, if the connector text value matches any value in the `noBranchValues`.
-The decision symbol produces two output branches: a Yes branch and a No branch. If the connector text value matches any value in the [`yesBranchValues`](https://ej2.syncfusion.com/react/documentation/api/diagram/flowchartLayoutSettingsModel/#yesbranchvalues) property of the [`flowchartLayoutSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/flowchartLayoutSettingsModel/) class, it will be considered a Yes branch. Similarly, if the connector text value matches any value in the [`noBranchValues`](https://ej2.syncfusion.com/react/documentation/api/diagram/flowchartLayoutSettingsModel/#nobranchvalues) property, it will be considered a No branch. By default, the `yesBranchValues` property contains the string values **Yes** and **True**, while the `noBranchValues` property contains **No** and **False**.
+By default:
+- **`yesBranchValues`** contains: **"Yes"** and **"True"**.
+- **`noBranchValues`** contains: **"No"** and **"False"**.
-Any text can be used as the connector text to describe the flow. Additionally, custom string values can be assigned to the `yesBranchValues` and `noBranchValues` properties. To direct the flow based on a conditional decision (if/else), the connector text must match a value in either the `yesBranchValues` or `noBranchValues` properties.
+### Custom Branch Classification
-The following example shows how to set custom text to the yes branch and no branch values.
+When a connector's text value matches any value in the `yesBranchValues` array, it is classified as a Yes branch. Similarly, when the connector text matches any value in the `noBranchValues` array, it is classified as a No branch. This enables flexible decision flow control using custom terminology appropriate for your specific use case.
+The following example demonstrates how to set custom text values for yes and no branches.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -254,4 +260,4 @@ The following example shows how to set custom text to the yes branch and no bran
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/flowchart-cs4" %}
-
\ No newline at end of file
+
\ No newline at end of file
diff --git a/ej2-react/diagram/getting-started.md b/ej2-react/diagram/getting-started.md
index 8094edea9..61caef9ba 100644
--- a/ej2-react/diagram/getting-started.md
+++ b/ej2-react/diagram/getting-started.md
@@ -1,16 +1,18 @@
---
layout: post
title: Getting Started with React Diagram Component | Syncfusion®
-description: Checkout and learn about getting started with Syncfusion Essential® React Diagram component, it's elements, and more.
+description: Checkout and learn about getting started with Syncfusion Essential® React Diagram Component, it's elements, and more.
control: Getting started
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Getting Started with React Diagram
+# Getting Started with React Diagram Component
-This section explains the steps required to create a simple diagram and demonstrates the basic usage of the diagram control.
+This section explains the steps required to create a simple diagram and demonstrates the basic usage of the diagram control in React applications.
+
+> **Ready to streamline your Syncfusion® React development?** Discover the full potential of Syncfusion® React components with Syncfusion® AI Coding Assistant. Effortlessly integrate, configure, and enhance your projects with intelligent, context-aware code suggestions, streamlined setups, and real-time insights—all seamlessly integrated into your preferred AI-powered IDEs like VS Code, Cursor, Syncfusion® CodeStudio and more. [Explore Syncfusion® AI Coding Assistant](https://ej2.syncfusion.com/react/documentation/ai-coding-assistants/overview)
> **Ready to streamline your Syncfusion® React development?** Discover the full potential of Syncfusion® React components with Syncfusion® AI Coding Assistant. Effortlessly integrate, configure, and enhance your projects with intelligent, context-aware code suggestions, streamlined setups, and real-time insights—all seamlessly integrated into your preferred AI-powered IDEs like VS Code, Cursor, Syncfusion® CodeStudio and more. [Explore Syncfusion® AI Coding Assistant](https://ej2.syncfusion.com/react/documentation/ai-coding-assistants/overview)
@@ -36,11 +38,11 @@ The following list of dependencies are required to use the `Diagram` component i
|-- @syncfusion/ej2-react-base
```
-## Installation and configuration
+## Installation and Configuration
To easily set up a React application, use `create-vite-app`, which provides a faster development environment, smaller bundle sizes, and optimized builds compared to traditional tools like `create-react-app`. For detailed steps, refer to the Vite [installation instructions](https://vitejs.dev/guide/). Vite sets up your environment using JavaScript and optimizes your application for production.
-> **Note:** To create a React application using `create-react-app`, refer to this [documentation](https://ej2.syncfusion.com/react/documentation/getting-started/create-app) for more details.
+> **Note:** To create a React application using `create-react-app`, refer to this [documentation](https://ej2.syncfusion.com/react/documentation/getting-started/create-app) for more details.
To create a new React application, run the following command.
@@ -62,19 +64,19 @@ cd my-app
npm run dev
```
-### Adding Syncfusion® packages
+### Adding Syncfusion® Packages
-All the available Essential® JS 2 packages are published in [`Node Package Manager`](https://www.npmjs.com/~syncfusionorg) public registry. You can choose the component that you want to install. For this application, we are going to use `Diagram` component.
+All the available Essential® JS 2 packages are published in [`Node Package Manager`](https://www.npmjs.com/~syncfusionorg) public registry. You can choose the component that you want to install. For this application, we are going to use the `Diagram` component.
-To install Diagram component, use the following command
+To install the Diagram component, use the following command:
```bash
npm install @syncfusion/ej2-react-diagrams --save
```
-### Adding Style sheet to the Application
+### Adding Style Sheet to the Application
-The following CSS files are available in ../node_modules/@syncfusion package folder. This can be added as reference in `src/App.css`.
+The following CSS files are available in ../node_modules/@syncfusion package folder. Add these references in `src/App.css`.
```css
@import "../node_modules/@syncfusion/ej2-react-diagrams/styles/material.css";
@@ -85,86 +87,11 @@ The following CSS files are available in ../node_modules/@syncfusion package fol
```
N> To refer App.css in the application, import it in the src/App.tsx file. `import './App.css';`
+## Adding Diagram Component to the Application
-## Module Injection
-
-The diagram component is divided into individual feature-wise modules. In order to use a particular feature, you need to inject its feature service in the App. The following list describes the module names and their description.
-
-* `BpmnDiagrams` - Inject this provider to add built-in BPMN Shapes to diagrams.
-* `ConnectorBridging` - Inject this provider to add bridges to connectors.
-* `ConnectorEditing` - Inject this provider to edit the segments for connector.
-* `ComplexHierarchicalTree` - Inject this provider to complex hierarchical tree like structure.
-* `DataBinding` - Inject this provider to populate nodes from given data source.
-* `DiagramContextMenu` - Inject this provider to manipulate context menu.
-* `HierarchicalTree` - Inject this provider to use hierarchical tree like structure.
-* `LayoutAnimation` - Inject this provider animation to layouts.
-* `MindMap` - Inject this provider to use mind map.
-* `PrintAndExport` - Inject this provider to print or export the objects.
-* `RadialTree` - Inject this provider to use Radial tree like structure.
-* `Snapping` - Inject this provider to Snap the objects.
-* `SymmetricLayout` - Inject this provider to render layout in symmetrical method.
-* `UndoRedo` - Inject this provider to revert and restore the changes.
-* `Ej1Serialization` - Inject this provider to load ej1 diagram json in ej2 diagram.
+To include the Diagram component in your application, import the `DiagramComponent` from the `ej2-react-diagrams` package.
-These modules should be injected into the diagram using the **Inject** directive.
-
-```javascript
-import * as React from "react";
-import * as ReactDOM from "react-dom";
-import {
- DiagramComponent,
- HierarchicalTree,
- MindMap,
- RadialTree,
- ComplexHierarchicalTree,
- DataBinding,
- Snapping,
- PrintAndExport,
- BpmnDiagrams,
- SymmetricLayout,
- ConnectorBridging,
- UndoRedo,
- LayoutAnimation,
- DiagramContextMenu,
- ConnectorEditing,
- Ej1Serialization,
- Inject
-} from "@syncfusion/ej2-react-diagrams";
-
-export default function App() {
- return (
-
-
-
- );
-}
-const root = ReactDOM.createRoot(document.getElementById("diagram"));
-root.render();
-```
-
-### Adding Diagram component to the Application
-
-* To include the Diagram component in application import the `DiagramComponent` from `ej2-react-diagrams` package.
-
-* Then add the Diagram component as shown in below code example.
+Then add the Diagram component as shown in the code example below.
`[src/App.jsx]`
@@ -187,7 +114,7 @@ export default App;
## Defining Basic Diagram
-The below examples shows the basic diagram component which renders an empty diagram.
+The example below shows a basic diagram component that renders an empty diagram canvas.
{% tabs %}
{% highlight js tabtitle="App.jsx" %}
@@ -203,29 +130,31 @@ The below examples shows the basic diagram component which renders an empty diag
{% previewsample "page.domainurl/code-snippet/diagram/getting-started/initialize-cs1" %}
-Now run the `npm run dev` command in the console to start the development server. This command compiles your code and serves the application locally, opening it in the browser.
+Now run the `npm run dev` command in the console to start the development server. This command compiles your code and serves the application locally,opening it in the browser.
```
npm run dev
```
-## Basic Diagram elements
-
-* `Node`: Visualizes any graphical object using nodes, which can also be arranged and manipulated on a diagram page.
-* `Connector`: Represents the relationship between two nodes. Three types of connectors provided as follows:
+## Basic Diagram Elements
-```
+Understanding the core elements of a diagram helps you build effective visualizations:
-1) Orthogonal
-2) Bezier
-3) Straight
+* **Node**: Visualizes any graphical object using nodes, which can be arranged and manipulated on a diagram page. Use nodes to represent entities, processes, or decision points.
+* **Connector**: Represents the relationship between two nodes. Three types of connectors are provided:
```
-* `Port`: Acts as the connection points of node or connector and allows you to create connections with only specific points.
-* `Annotation`: Shows additional information by adding text or labels on nodes and connectors.
+1) Orthogonal - Right-angled connectors for structured layouts.
+2) Bezier - Curved connectors for smooth, organic flows.
+3) Straight - Direct linear connections between nodes.
+```
+* **Port**: Acts as the connection points of nodes or connectors, allowing you to create connections with only specific points for precise layout control.
+* **Annotation**: Shows additional information by adding text or labels on nodes and connectors to provide context and meaning.
## Flow Diagram
+This section demonstrates how to create a flowchart by manually adding nodes and connecting them with connectors.
+
### Create and Add Node
Create and add a `node` (JSON data) with specific position, size, label, and shape.
@@ -244,13 +173,12 @@ Create and add a `node` (JSON data) with specific position, size, label, and sha
{% previewsample "page.domainurl/code-snippet/diagram/getting-started/addnode-cs1" %}
-### Apply shape and style to node
+### Apply Shape and Style to Node
-Syncfusion® diagram control provides support to render many built-in shapes in diagram.
-Please refer to [`Shapes`](shapes) to know about built-in Shapes.
-
-The appearance of a node can be customized by changing its [`fill`](../api/diagram/shapeStyleModel/#fill-string) color, [`strokeColor`](../api/diagram/shapeStyleModel/#strokecolor-string), [`strokeWidth`](../api/diagram/shapeStyleModel/#strokewidth-number), [`borderColor`](../api/diagram/node/#borderColor-string), [`borderWidth`](../api/diagram/node/#borderWidth-number), [`strokeDashArray`](../api/diagram/shapeStyleModel/#strokeDashArray-number), [`opacity`](../api/diagram/shapeStyleModel/#opacity-number), and [`shadow`](../api/diagram/shapeStyleModel/#shadow-number).
+The Syncfusion® diagram control provides support to render many built-in shapes in diagrams.
+Please refer to [`Shapes`](https://helpej2.syncfusion.com/react/documentation/api/diagram/shapes/) to know about built-in shapes.
+The appearance of a node can be customized by changing its [`fill`](../api/diagram/shapeStyleModel/#fill-string) color, [`strokeColor`](../api/diagram/shapeStyleModel/#strokecolor-string), [`strokeWidth`](../api/diagram/shapeStyleModel/#strokewidth-number), [`borderColor`](../api/diagram/node/#borderColor-string), [`borderWidth`](../api/diagram/node/#borderWidth-number), [`strokeDashArray`](../api/diagram/shapeStyleModel/#strokeDashArray-number), [`opacity`](../api/diagram/shapeStyleModel/#opacity-number), and [`shadow`](../api/diagram/shapeStyleModel/#shadow-number).
{% tabs %}
{% highlight js tabtitle="app.jsx" %}
@@ -266,9 +194,9 @@ The appearance of a node can be customized by changing its [`fill`](../api/diagr
{% previewsample "page.domainurl/code-snippet/diagram/getting-started/apply-style" %}
-### Add other flowchart nodes to the diagram
+### Add Other Flowchart Nodes to the Diagram
-You can add multiple nodes with different shapes into diagram.
+You can add multiple nodes with different shapes to create a complete flowchart diagram.
```Javascript
@@ -312,9 +240,9 @@ root.render();
```
-### Connect flow chart nodes
+### Connect Flow Chart Nodes
-Connect these nodes by adding a connector using the [`connectors`](../api/diagram/connectorModel/) property of diagram and refer the source and target end by using the [`sourceID`](../api/diagram/connectorModel/#sourceid) and [`targetID`](../api/diagram/connectorModel/#targetid) properties.
+Connect these nodes by adding a connector using the [`connectors`](../api/diagram/connectorModel/) property of the diagram and refer to the source and target end by using the [`sourceID`](../api/diagram/connectorModel/#sourceid) and [`targetID`](../api/diagram/connectorModel/#targetid) properties.
The required nodes and connectors can be added to form a complete flow diagram.
{% tabs %}
@@ -334,13 +262,86 @@ The required nodes and connectors can be added to form a complete flow diagram.
Default values for all [`nodes`](../api/diagram/nodemodel/) and [`connectors`](../api/diagram/connectorModel/) can be set using the [`getNodeDefaults`](../api/diagram/#getnodedefaults) and [`getConnectorDefaults`](../api/diagram/#getconnectordefaults) properties, respectively. For example, if all nodes have the same width and height, such properties can be moved into `getNodeDefaults`.
-## Automatic Organization Chart
+## Module Injection
-In ‘Flow Diagram’ section we saw how to create a diagram manually, now let us see how to create and position diagram automatically.
+The diagram component is divided into individual feature-wise modules. To use a particular feature, you need to inject its feature service in the App. For basic diagram functionality, you typically only need `DataBinding` and layout modules like `HierarchicalTree`. The following list describes the module names and their descriptions:
-### Create Business object (Employee information)
+* `BpmnDiagrams` - Inject this provider to add built-in BPMN Shapes to diagrams.
+* `ConnectorBridging` - Inject this provider to add bridges to connectors.
+* `ConnectorEditing` - Inject this provider to edit the segments for connectors.
+* `ComplexHierarchicalTree` - Inject this provider to use complex hierarchical tree-like structures.
+* `DataBinding` - Inject this provider to populate nodes from given data source.
+* `DiagramContextMenu` - Inject this provider to manipulate context menu.
+* `HierarchicalTree` - Inject this provider to use hierarchical tree-like structures.
+* `LayoutAnimation` - Inject this provider to add animation to layouts.
+* `MindMap` - Inject this provider to use mind map layouts.
+* `PrintAndExport` - Inject this provider to print or export the objects.
+* `RadialTree` - Inject this provider to use radial tree-like structures.
+* `Snapping` - Inject this provider to snap the objects.
+* `SymmetricLayout` - Inject this provider to render layouts in symmetrical method.
+* `UndoRedo` - Inject this provider to revert and restore the changes.
+* `Ej1Serialization` - Inject this provider to load ej1 diagram json in ej2 diagram.
-Define Employee Information as JSON data. The following code example shows an employee array whose, `Name` is used as an unique identifier and `ReportingPerson` is used to identify the person to whom an employee report to, in the organization.
+These modules should be injected into the diagram using the **Inject** directive.
+
+```javascript
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+import {
+ DiagramComponent,
+ HierarchicalTree,
+ MindMap,
+ RadialTree,
+ ComplexHierarchicalTree,
+ DataBinding,
+ Snapping,
+ PrintAndExport,
+ BpmnDiagrams,
+ SymmetricLayout,
+ ConnectorBridging,
+ UndoRedo,
+ LayoutAnimation,
+ DiagramContextMenu,
+ ConnectorEditing,
+ Ej1Serialization,
+ Inject
+} from "@syncfusion/ej2-react-diagrams";
+
+export default function App() {
+ return (
+
+
+
+ );
+}
+const root = ReactDOM.createRoot(document.getElementById("diagram"));
+root.render();
+```
+## Automatic Organizational Chart
+
+While the previous section showed how to create diagrams manually, this section demonstrates how to create and position diagrams automatically using data binding and layout algorithms.
+
+### Create Business Object (Employee Information)
+
+Define Employee Information as JSON data. The following code example shows an employee array where `Name` is used as a unique identifier and `ReportingPerson` is used to identify the person to whom an employee reports in the organization.
```ts
const data: Object[] = [
@@ -381,11 +382,12 @@ Define Employee Information as JSON data. The following code example shows an em
];
```
-### Map data source
+### Map Data Source
-You can configure the above "Employee Information" with diagram, so that the nodes and connectors are automatically generated using the mapping properties. The following code example demonstrates how to use [`dataSourceSettings`](../api/diagram/datasourcemodel/) to map [`id`](../api/diagram/dataSourceModel/#id) and [`parentId`](../api/diagram/dataSourceModel/#parentid) with the corresponding property names of employee information.
+You can configure the above "Employee Information" with the diagram, so that the nodes and connectors are automatically generated using the mapping properties. The following code example demonstrates how to use [`dataSourceSettings`](../api/diagram/datasourcemodel/) to map [`id`](../api/diagram/dataSourceModel/#id) and [`parentId`](../api/diagram/dataSourceModel/#parentid) with the corresponding property names of employee information.
```ts
+import { DataManager } from "@syncfusion/ej2-data";
export default function App() {
const data: Object[] = [
@@ -444,9 +446,9 @@ const root = ReactDOM.createRoot(document.getElementById("diagram"));
root.render();
```
-### Rendering layout with Datasource
+### Rendering Layout with Data Source
-To create an organizational chart, the [`type`](../api/diagram/layoutType/) of layout should be set as an `OrganizationalChart`. The following code example shows how DataManager is used to generate Layout based on the DataSourceSettings of the Diagram.
+To create an organizational chart, the [`type`](../api/diagram/layoutType/) of layout should be set as an `OrganizationalChart`. The following code example shows how DataManager is used to generate layouts based on the DataSourceSettings of the Diagram.
{% tabs %}
{% highlight js tabtitle="app.jsx" %}
@@ -462,8 +464,7 @@ To create an organizational chart, the [`type`](../api/diagram/layoutType/) of l
{% previewsample "page.domainurl/code-snippet/diagram/getting-started/orgchart-cs1" %}
-
-### Customize employee appearance
+### Customize Employee Appearance
The following code examples indicate how to define the default appearance of nodes and connectors. The [`setNodeTemplate`](../api/diagram/#setnodetemplate) is used to update each node based on employee data.
diff --git a/ej2-react/diagram/grid-lines.md b/ej2-react/diagram/grid-lines.md
index 826e616cd..304423acf 100644
--- a/ej2-react/diagram/grid-lines.md
+++ b/ej2-react/diagram/grid-lines.md
@@ -1,20 +1,24 @@
---
layout: post
-title: Grid lines in React Diagram component | Syncfusion®
-description: Learn here all about Grid lines in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Grid lines in React Diagram Component | Syncfusion®
+description: Learn here all about Grid lines in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Grid lines
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Grid lines in EJ2 React Diagram component
+# Grid Lines in EJ2 React Diagram Component
-Gridlines are crisscross lines drawn in diagram page like the lines on traditional graph paper. It helps to position the diagram elements on the diagram page.
+Gridlines are crisscross lines drawn in diagram pages like the lines on traditional graph paper. They help position diagram elements precisely on the diagram page and provide visual reference points for accurate layout design.
+
+## Prerequisites
+
+To use gridlines and snapping functionality, ensure that the snapping module is injected into the diagram component.
The [`snapSettings`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#snapsettings) property is used to customize the gridlines and control the snapping behavior in the diagram.
-## Customize the gridlines visibility
+## Customize the Gridlines Visibility
The [`snapConstraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/snapSettings/#constraints) enables you to show/hide the gridlines. The following code example illustrates how to show the gridlines.
@@ -35,13 +39,13 @@ To show only horizontal/vertical gridlines or to hide gridlines, refer to [`Cons
## Appearance
-The appearance of the gridlines can be customized by using a set of predefined properties.
+The appearance of the gridlines can be customized using a set of predefined properties to match your application's design requirements.
* The [`horizontalGridLines`](https://helpej2.syncfusion.com/react/documentation/api/diagram/snapSettings/#horizontalgridlines) and the [`verticalGridLines`](https://helpej2.syncfusion.com/react/documentation/api/diagram/snapSettings/#verticalgridlines) properties allow you to customize the appearance of the horizontal and vertical gridlines respectively.
* The horizontal gridlines [`lineColor`](https://helpej2.syncfusion.com/react/documentation/api/diagram/gridlines/#linecolor) and [`lineDashArray`](https://helpej2.syncfusion.com/react/documentation/api/diagram/gridlines/#linedasharray) properties are used to customizes the line color and line style of the horizontal gridlines.
-* The vertical gridlines [`lineColor`](https://helpej2.syncfusion.com/react/documentation/api/diagram/gridlines/#linecolor) and [`lineDashArray`](https://helpej2.syncfusion.com/react/documentation/api/diagram/gridlines/#linedasharray) properties are used to customizes the line color and line style of the vertical gridlines.
+* The vertical gridlines `lineColor` and [`lineDashArray`](https://helpej2.syncfusion.com/react/documentation/api/diagram/gridlines/#linedasharray) properties are used to customizes the line color and line style of the vertical gridlines.
The following code example illustrates how to customize the appearance of gridlines.
@@ -58,9 +62,9 @@ The following code example illustrates how to customize the appearance of gridli

-## Line intervals
+## Line Intervals
-Thickness and the space between gridlines can be customized by using horizontal gridlines’s [`linesInterval`](https://helpej2.syncfusion.com/react/documentation/api/diagram/gridlines/#lineintervals) and vertical gridlines’s [`linesInterval`](https://helpej2.syncfusion.com/react/documentation/api/diagram/gridlines/#lineintervals) properties. In the lines interval collections, values at the odd places are referred as the thickness of lines and values at the even places are referred as the space between gridlines.
+The thickness and spacing between gridlines can be customized using the horizontal gridlines's [`linesInterval`](https://helpej2.syncfusion.com/react/documentation/api/diagram/gridlines/#lineintervals) and vertical gridlines’s `linesInterval` properties. In the lines interval collections, values at the odd places are referred as the thickness of lines and values at the even places are referred as the space between gridlines.
The following code example illustrates how to customize the thickness of lines and the line intervals.
@@ -77,11 +81,11 @@ The following code example illustrates how to customize the thickness of lines a

-## Dot grid patterns
+## Dot Grid Patterns
-The appearance of the grid lines can be changed into dots by settings [`gridType`](https://helpej2.syncfusion.com/react/documentation/api/diagram/gridType/) of `snapSettings` as Dots. By default, the grid type is **Lines**.
+The appearance of the grid lines can be changed into dots by setting the [`gridType`](https://helpej2.syncfusion.com/react/documentation/api/diagram/gridType/) of `snapSettings` as Dots. By default, the grid type is **Lines**.Dot patterns can be particularly useful for creating a less intrusive visual guide while maintaining alignment functionality.
-The following code illustrates how to render grid patterns as Dots.
+The following code illustrates how to render grid patterns as dots.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -98,13 +102,13 @@ The following code illustrates how to render grid patterns as Dots.
## Snapping
-When you draw, resize, or move a diagram element on the page, you can set it to align or snap to the nearest intersection, regardless of whether the grid is visible.
+Snapping functionality works in conjunction with gridlines to provide precise alignment capabilities. When you draw, resize, or move a diagram element on the page, you can set it to align or snap to the nearest intersection, regardless of whether the grid is visible.
-## Snap to lines
+## Snap to Lines
This feature allows diagram objects to snap to the nearest intersection of gridlines while being dragged or resized, facilitating easier alignment during layout or design.
-Snapping to gridlines can be enabled or disabled using the [`snapConstraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/snapSettings/#constraints) property of the SnapSettings class. The default value is All.
+Snapping to gridlines can be enabled or disabled using the `snapConstraints` property of the SnapSettings class. The default value is **All**.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -119,11 +123,11 @@ Snapping to gridlines can be enabled or disabled using the [`snapConstraints`](h

-## Snap to objects
+## Snap to Objects
The snap-to-object feature provides visual cues to assist with aligning and spacing diagram elements. A node can snap to its neighboring objects based on specific alignments, such as the same size and position. These alignments are visually represented by smart guide lines in a cyan shade, with the color code '#07EDE1'.
-The [`snapObjectDistance`](https://helpej2.syncfusion.com/react/documentation/api/diagram/snapSettings/#snapobjectdistance) property allows you to define minimum distance between the selected object and the nearest object. By default, the snap object distance is set to 5.
+The [`snapObjectDistance`](https://helpej2.syncfusion.com/react/documentation/api/diagram/snapSettings/#snapobjectdistance) property allows you to define minimum distance between the selected object and the nearest object. By default, the snap object distance is set to **5 pixels**.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -142,7 +146,7 @@ The [`snapObjectDistance`](https://helpej2.syncfusion.com/react/documentation/ap
The [`snapAngle`](https://helpej2.syncfusion.com/react/documentation/api/diagram/snapSettings/#snapangle) property defines the increments by which an object can be rotated within a diagram.
-For example, if the snapAngle is set to 15 degrees, an object can only be rotated to angles that are multiples of 15 degrees, such as 15°, 30°, 45°, and so on. This ensures precise angule alignment and consistent object positioning, enhancing the overall design accuracy. By default, the snap angle is set to 5"
+For example, if the snapAngle is set to 15 degrees, an object can only be rotated to angles that are multiples of 15 degrees, such as 15°, 30°, 45°, and so on. This ensures precise angular alignment and consistent object positioning, enhancing the overall design accuracy. By default, the snap angle is set to 5 degrees.
The following code example demonstrates how to set the `snapAngle` property and update it dynamically.
@@ -158,7 +162,8 @@ The following code example demonstrates how to set the `snapAngle` property and
{% previewsample "page.domainurl/code-snippet/diagram/gridLines/es5SnapAngle-cs1" %}

-## Snap line color
+
+## Snap Line Color
The [`snapLineColor`](https://helpej2.syncfusion.com/react/documentation/api/diagram/snapSettings/#snaplinecolor) property allows you to define the color of the snapline used in the diagram. By customizing the snapline color, you can enhance the visual contrast and visibility of these guides, making it easier to achieve accurate alignment.
@@ -177,9 +182,9 @@ The following code example demonstrates how to set the `snapLineColor` property
{% previewsample "page.domainurl/code-snippet/diagram/gridLines/es5SnapColor-cs1" %}
-## Customization of snap intervals
+## Customization of Snap Intervals
-By default, the objects are snapped towards the nearest gridline. The gridline or position towards where the diagram object snaps can be customized with the horizontal gridlines’s [`snapInterval`](https://helpej2.syncfusion.com/react/documentation/api/diagram/gridlines/#snapintervals) and the vertical gridlines’s [`snapInterval`](https://helpej2.syncfusion.com/react/documentation/api/diagram/gridlines/#snapintervals) properties.
+By default, the objects are snapped towards the nearest gridline. The gridline or position towards where the diagram object snaps can be customized with the horizontal gridlines’s [`snapInterval`](https://helpej2.syncfusion.com/react/documentation/api/diagram/gridlines/#snapintervals) and the vertical gridlines’s `snapInterval` properties.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -192,6 +197,6 @@ By default, the objects are snapped towards the nearest gridline. The gridline o
{% previewsample "page.domainurl/code-snippet/diagram/gridLines/es5SnapInterval-cs1" %}
-## Snap constraints
+## Snap Constraints
-The [`snapConstraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/snapSettings/#constraints) property allows you to enable or disable the certain features of the snapping, for detailed information refer to [`constraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/snapConstraints).
+The `snapConstraints` property allows you to enable or disable certain features of the snapping functionality. For detailed information refer to [`constraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/snapConstraints).
diff --git a/ej2-react/diagram/group.md b/ej2-react/diagram/group.md
index 387dbd4fe..15c7618bf 100644
--- a/ej2-react/diagram/group.md
+++ b/ej2-react/diagram/group.md
@@ -1,20 +1,21 @@
---
layout: post
-title: Group in React Diagram component | Syncfusion®
-description: Learn here all about Group in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Group in React Diagram Component | Syncfusion®
+description: Learn here all about Group in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Group
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Group in React Diagram component
+# Group in React Diagram Component
+Groups enable developers to cluster multiple nodes and connectors into a single manageable element, acting as a container that maintains relationships between child elements while allowing both collective and individual manipulation. This powerful feature streamlines complex diagram management by treating related elements as cohesive units while preserving the ability to edit individual components when needed.
-## Create group
+## Create Group
-Group is used to cluster multiple nodes and connectors into a single element. It acts like a container for its children (nodes, groups, and connectors). Every change made to the group also affects the children. Child elements can be edited individually.
+A group functions as a container for its children (nodes, groups, and connectors). Every change made to the group affects all children proportionally, while child elements remain individually editable. Groups can contain other groups, creating nested hierarchies for complex diagram structures.
-## Add group when initializing diagram
+## Add Group when Initializing Diagram
A group can be added to the diagram model through [`nodes`](https://ej2.syncfusion.com/react/documentation/api/diagram/#nodes) collection. To define an object as group, add the child objects to the [`children`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#children) collection of the group. The following code illustrates how to create a group node.
@@ -44,9 +45,11 @@ Connectors can be added to a group. The following code illustrates how to add co
{% previewsample "page.domainurl/code-snippet/diagram/group/groupaddconnector-cs1" %}
-## Group nodes at runtime
+## Runtime Group Operations
-Groups can be dynamically created during runtime in the diagram by invoking the [`diagram.group`](https://ej2.syncfusion.com/react/documentation/api/diagram/#group) method. To initiate this process, first, select the nodes that you intend to include within the group. Subsequently, by utilizing the [`diagram.group`](https://ej2.syncfusion.com/react/documentation/api/diagram/#group) method, the selected nodes will be encapsulated within a newly formed group node.
+### Group Nodes at Runtime
+
+Groups can be dynamically created during runtime in the diagram by invoking the [`diagram.group`](https://ej2.syncfusion.com/react/documentation/api/diagram/#group) method. To initiate this process, first, select the nodes that you intend to include within the group. Subsequently, by utilizing the `diagram.group` method will encapsulate the selected nodes within a newly formed group node.
The following code illustrates how to group at runtime.
@@ -61,9 +64,10 @@ The following code illustrates how to group at runtime.
{% previewsample "page.domainurl/code-snippet/diagram/group/group-runtime" %}
-## UnGroup nodes at runtime
+### Ungroup Nodes at Runtime
-Group node can be unGrouped dynamically, by using the [`diagram.unGroup`](https://ej2.syncfusion.com/react/documentation/api/diagram/#ungroup) method. The following code example shows how to unGroup group node at runtime.
+Group node can be unGrouped dynamically using the [`diagram.unGroup`](https://ej2.syncfusion.com/react/documentation/api/diagram/#ungroup) method.This operation dissolves the group container while preserving all child elements as individual diagram elements.
+The following code example shows how to ungroup a group node at runtime:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -76,11 +80,11 @@ Group node can be unGrouped dynamically, by using the [`diagram.unGroup`](https:
{% previewsample "page.domainurl/code-snippet/diagram/group/ungroup-runtime" %}
-## Add group node at runtime
+### Add Group Node at Runtime
-A group node can be added at runtime by using the diagram method [`diagram.add`](https://ej2.syncfusion.com/react/documentation/api/diagram/#add).
+A group node can be added at runtime by using the diagram method [`diagram.add`](https://ej2.syncfusion.com/react/documentation/api/diagram/#add).This method allows programmatic addition of predefined group structures to an existing diagram.
-The following code illustrates how a group node is added at runtime.
+The following code illustrates how a group node is added at runtime:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -93,9 +97,9 @@ The following code illustrates how a group node is added at runtime.
{% previewsample "page.domainurl/code-snippet/diagram/group/groupadd-cs1" %}
-## Add collection of group nodes at runtime
+### Add Collection of Group Nodes at Runtime
-* The collection of group nodes can be dynamically added using [`addElements`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addelements) method.Each time an element is added to the diagram canvas, the [`collectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/iCollectionChangeEventArgs/) event will be triggered.
+The collection of group nodes can be dynamically added using the [`addElements`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addelements) method.Each time an element is added to the diagram canvas, the [`collectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/iCollectionChangeEventArgs/) event will be triggered.
The following code illustrates how to add group nodes collection at runtime.
@@ -110,28 +114,24 @@ The following code illustrates how to add group nodes collection at runtime.
{% previewsample "page.domainurl/code-snippet/diagram/group/groupcollection-cs1" %}
-## Add/Remove children from group
-
-### Add children To group at runtime
+## Manage Group Children at Runtime
-A childNode can be added to the specified Group at runtime by utilizing the diagram method [`diagram.addChildToGroup`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addchildtogroup).
+### Add Children to Group at Runtime
-This functionality is achieved by passing the group and existing children as arguments to the method.
+A child node can be added to a specified group at runtime using the diagram method [`diagram.addChildToGroup`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addchildtogroup). This functionality requires passing the group and the existing child node as arguments to the method.
-The following code illustrates how a child node and a group node can be passed as arguments to the method and executed at runtime.
+The following code illustrates how a child node can be added to a group node at runtime:
```html
diagram.addChildToGroup(groupNode, childNode);
```
-### Remove children from group at runtime
-
-A specific child from a group node can be removed at runtime by utilizing the diagram method [`diagram.removeChildFromGroup`](https://ej2.syncfusion.com/react/documentation/api/diagram/#removechildfromgroup).
+### Remove Children from Group at Runtime
-This functionality is achieved by passing the group and its children as arguments to the method.
+A specific child from a group node can be removed at runtime by utilizing the diagram method [`diagram.removeChildFromGroup`](https://ej2.syncfusion.com/react/documentation/api/diagram/#removechildfromgroup). This functionality requires passing the group and its child node as arguments to the method.
-The following code illustrates how a child node is removed from a group at runtime.
+The following code illustrates how a child node is removed from a group at runtime:
```html
@@ -149,11 +149,14 @@ diagram.removeChildFromGroup (groupNode, childNode);
{% previewsample "page.domainurl/code-snippet/diagram/group/groupchild-cs1" %}
-## Group padding
+## Group Styling and Layout
-The [`Padding`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeModel/#padding) property of a group node defines the spacing between the group node’s edges and its children.
+### Group Padding
-The following code illustrates how to add Padding to the node group.
+
+The [`Padding`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeModel/#padding) property of a group node defines the spacing between the group node's edges and its children. This property helps maintain visual separation and improves the overall appearance of grouped elements.
+
+The following code illustrates how to add padding to a node group:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -166,16 +169,15 @@ The following code illustrates how to add Padding to the node group.
{% previewsample "page.domainurl/code-snippet/diagram/group/group-padding" %}
-## Group flip
-
-The flip functionality for a group node works similarly to that of normal nodes. However, when flipping a group node, the flip of its child nodes is combined with the group's flip. This combination ensures that the child nodes inherit the group’s flip while retaining their own individual flips.
+### Group Flip
-`Example`:
+The flip functionality for a group node works similarly to that of normal nodes. When flipping a group node, the child nodes inherit the group's flip transformation while retaining their individual flip settings. The combined effect creates a hierarchical flip behavior where both the group and child transformations are applied.
-- If a child node’s flip is set to Vertical and the group node’s flip is set to Horizontal, the resulting flip for the child node will be a combination of Vertical and Horizontal (effectively a "both" flip).
-- This ensures that the child nodes’ orientations adapt dynamically based on the group’s flip while maintaining their unique flip settings.
+**Example of combined flip behavior:**
+- If a child node's flip is set to Vertical and the group node's flip is set to Horizontal, the resulting flip for the child node combines both transformations (effectively a "both" flip).
+- This ensures that child nodes adapt dynamically based on the group's flip while maintaining their unique flip settings.
-The following example shows how to apply flip for group node.
+The following example shows how to apply flip transformations to group nodes:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -188,14 +190,12 @@ The following example shows how to apply flip for group node.
{% previewsample "page.domainurl/code-snippet/diagram/group/group-flip" %}
-### Group flip mode
+### Group Flip Mode
-The [`flipMode`](https://ej2.syncfusion.com/angular/documentation/api/diagram/flipMode/) of a group node also behave similarly to those of normal nodes. However,When you apply a flip mode to a group node, it takes precedence over any flip mode set on its child nodes, overriding their individual settings.
+The [`flipMode`](https://ej2.syncfusion.com/react/documentation/api/diagram/flipMode/)property of a group node behaves similarly to that of normal nodes. However, when a flip mode is applied to a group node, it takes precedence over any flip mode set on its child nodes, overriding their individual settings.
-For example, in the below code,
-the flipMode for the child node `Node1` is set to `LabelText`.
-The flipMode for the group node is set to `Label`.
-As a result, the effective flipMode for both the child node and the group node will be Label, as the group node’s flipMode overrides the child’s.
+**Example of flip mode precedence:**
+In the code below, the `flipMode` for the child node `Node1` is set to `LabelText`, while the `flipMode` for the group node is set to `Label`. The effective `flipMode` for both the child node and the group node will be `Label`, as the group node's `flipMode` overrides the child's setting.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -210,13 +210,13 @@ As a result, the effective flipMode for both the child node and the group node w
-## Nested group
+## Nested Group
-Nested groups are essentially groups within groups, where a group can contain other groups as its children, creating a hierarchy that helps manage complexity and relationships between different elements.
+Nested groups are groups within groups, where a group can contain other groups as its children, creating a hierarchical structure. This feature helps manage complexity and relationships between different elements in sophisticated diagram scenarios.

- The following code illustrates how to create nested group node.
+ The following code illustrates how to create nested group nodes:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -229,9 +229,11 @@ Nested groups are essentially groups within groups, where a group can contain ot
{% previewsample "page.domainurl/code-snippet/diagram/group/group-nested" %}
-## Add Group in palette
+### Add Groups to Symbol Palette
-Group node can be added in symbol palette like the normal nodes. The following code illustrates how to render group node in palette.
+Group nodes can be added to the symbol palette like normal nodes, enabling reusable group templates for consistent diagram creation. This feature allows developers to create standardized group configurations that can be dragged and dropped into diagrams.
+
+The following code illustrates how to render group nodes in the palette:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -244,9 +246,11 @@ Group node can be added in symbol palette like the normal nodes. The following
{% previewsample "page.domainurl/code-snippet/diagram/group/group-palette" %}
-## Update group node at runtime
+### Update Group Nodes at Runtime
+
+Groups can be updated dynamically similar to normal nodes, allowing modification of group properties, styling, and behavior during runtime operations.
-Group can be updated dynamically similar to the normal nodes. The following code illustrates how to update group node at runtime.
+The following code illustrates how to update group nodes at runtime:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -259,23 +263,20 @@ Group can be updated dynamically similar to the normal nodes. The following cod
{% previewsample "page.domainurl/code-snippet/diagram/group/group-update" %}
-## Container
-
-Containers are used to automatically measure and arrange the size and position of the child elements in a predefined manner. There are two types of containers available.
-
-***Canvas***
-
-* The canvas panel supports absolute positioning and provides the least layout functionality to its contained diagram elements.
-
-* Canvas allows you to position its contained elements by using the margin and alignment properties.
+## Container Types
-* Rendering alone possible in canvas container.
+Containers provide automatic measurement and arrangement of child element size and position according to predefined layout behaviors. The diagram supports two container types, each optimized for different layout scenarios.
-* It allows elements to be either vertically or horizontally aligned.
+### Canvas Container
-* Child can be defined with the collection [`canvas.children`](https://ej2.syncfusion.com/react/documentation/api/diagram/canvas/#children) property.
+The canvas panel supports absolute positioning and provides minimal layout functionality to its contained diagram elements. This container type offers maximum flexibility for precise element placement.
-* Basic element can be defined with the collection of `basicElements`.
+**Canvas Container Characteristics:**
+- Supports absolute positioning using margin and alignment properties.
+- Enables rendering operations independently for each contained element.
+- Allows elements to be aligned vertically or horizontally.
+- Child elements are defined using the [`canvas.children`](https://ej2.syncfusion.com/react/documentation/api/diagram/canvas/#children) property.
+- Basic elements can be defined within the `basicElements` collection.
The following code illustrates how to add canvas panel.
@@ -290,13 +291,17 @@ The following code illustrates how to add canvas panel.
{% previewsample "page.domainurl/code-snippet/diagram/group/es5canvas-cs1" %}
-***Stack***
+### Stack Container
-* Stack panel is used to arrange its children in a single line or stack order, either vertically or horizontally.
+The stack panel arranges its children in a single line or stack order, either vertically or horizontally. This container provides structured layout control through spacing and alignment properties.
-* It controls spacing by setting margin properties of child and padding properties of group. By default, a stack panel’s [`orientation`](https://ej2.syncfusion.com/react/documentation/api/diagram/stackPanel/#orientation) is vertical.
+**Stack Container Characteristics:**
+- Controls spacing using margin properties of child elements and padding properties of the group.
+- Default [`orientation`](https://ej2.syncfusion.com/react/documentation/api/diagram/stackPanel/#orientation)is vertical.
+- Provides consistent alignment and distribution of child elements.
+- Ideal for creating organized, sequential layouts.
-The following code illustrates how to add a stack panel.
+The following code illustrates how to add a stack panel:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -309,33 +314,33 @@ The following code illustrates how to add a stack panel.
{% previewsample "page.domainurl/code-snippet/diagram/group/es5stack-cs1" %}
-## Difference between a basic group and containers
+### Difference Between Basic Groups and Containers
-| Group | Container |
+| Basic Group | Container |
| -------- | -------- |
-| It arranges the child elements based on the child elements position and size properties. | Each container has a predefined behavior to measure and arrange its child elements. Canvas and stack containers are supported in the diagram. |
-| The Padding, Min, and Max Size properties are not applicable for basic group. | It is applicable for container. |
-| The Children’s margin and alignment properties are not applicable for basic group. | It is applicable for container. |
+| Arranges child elements based on the child elements' position and size properties | Each container has predefined behavior to measure and arrange child elements. Canvas and stack containers are supported in the diagram |
+| The padding, minimum, and maximum size properties are not applicable for basic groups | These properties are applicable for containers |
+| The children's margin and alignment properties are not applicable for basic groups | These properties are applicable for containers |
-## Interaction
+## Group Interactions
-Group node interactions can be performed similarly to normal nodes. Fundamental diagram interactions like selecting, dragging, resizing, and rotating apply equally to group nodes. For more informatation refer to the [`nodes interactions`](./nodes-interaction)
+Group node interactions can be performed similarly to normal nodes. Fundamental diagram interactions like selecting, dragging, resizing, and rotating apply equally to group nodes. For more information, refer to the [node interactions](./nodes-interaction) documentation.
-### Selecting a Node Group
+### Selecting Group Nodes
-When a child element within a node group is clicked, the entire contained node group is selected instead of the individual child element. Subsequent clicks on the selected element change the selection from top to bottom within the hierarchy, moving from the parent node group to its children.
+When a child element within a node group is clicked, the entire containing node group is selected instead of the individual child element. Subsequent clicks on the selected element change the selection from top to bottom within the hierarchy, moving from the parent node group to its children.

## Events
-The events triggered when interacting with group nodes are similar to those for individual nodes. For more information, refer to the [`nodes events`](./nodes-events)
+The events triggered when interacting with group nodes are similar to those for individual nodes. For more information, refer to the [`nodes events`](./nodes-events) documentation.
## See Also
-* [How to add annotations to the node](./labels)
-* [How to add ports to the node](./ports)
-* [How to enable/disable the behavior of the node](./constraints)
-* [How to add nodes to the symbol palette](./symbol-palette)
-* [How to create diagram nodes using drawing tools](./tools)
-* [How to perform the interaction on the group](./interaction#selection)
\ No newline at end of file
+* [How to add annotations to the node.](./labels)
+* [How to add ports to the node.](./ports)
+* [How to enable/disable the behavior of the node.](./constraints)
+* [How to add nodes to the symbol palette.](./symbol-palette)
+* [How to create diagram nodes using drawing tools.](./tools)
+* [How to perform the interaction on the group.](./interaction#selection)
\ No newline at end of file
diff --git a/ej2-react/diagram/hierarchical-layout.md b/ej2-react/diagram/hierarchical-layout.md
index 23619ac7b..fb33ab470 100644
--- a/ej2-react/diagram/hierarchical-layout.md
+++ b/ej2-react/diagram/hierarchical-layout.md
@@ -1,20 +1,20 @@
---
layout: post
-title: Hierarchical tree layout in React Diagram component | Syncfusion®
-description: Learn here all about Hierarchical tree layout in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Hierarchical tree layout in React Diagram Component | Syncfusion®
+description: Learn here all about Hierarchical tree layout in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Hierarchical tree layout
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Hierarchical tree layout in React Diagram control
+# Hierarchical Tree Layout in React Diagram Component
-The hierarchical tree layout arranges nodes in a tree-like structure, where the nodes in the hierarchical layout may have multiple parents. There is no need to specify the layout root.
+The hierarchical tree layout arranges nodes in a tree-like structure where nodes can have multiple parent nodes, creating complex organizational relationships. Unlike traditional tree structures with single parent-child relationships, this layout supports scenarios such as matrix organizations, project dependencies, or any structure where entities report to multiple authorities. The layout automatically determines positioning without requiring a specified root node.
-## Hierarchical tree layout with nodes and connectors
+## Hierarchical Tree Layout with Nodes and Connectors
-To arrange the nodes in a hierarchical structure, specify the layout [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#type) as **HierarchicalTree**. The following example shows how to arrange the nodes in a hierarchical structure.
+To arrange nodes in a hierarchical structure, specify the layout [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#type) as **HierarchicalTree**. This approach provides full control over node and connector definitions while leveraging automatic positioning.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -27,12 +27,11 @@ To arrange the nodes in a hierarchical structure, specify the layout [`type`](ht
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/hierarchicallayout-cs1" %}
->Note: If you want to use hierarchical tree layout in diagram, you need to inject HierarchicalTree in the diagram.
+>Note: The HierarchicalTree module must be injected into the diagram to use hierarchical tree layout functionality.
-## Hierarchical layout with DataSource
-
-You can create a hierarchical layout with data Source. The following code demonstrates how to render a Hierarchical layout using DataSource.
+## Hierarchical Layout with DataSource
+For data-driven scenarios, hierarchical layout can be created using a DataSource, which automatically generates nodes and connectors based on the data relationships. This approach is more efficient for large datasets and dynamic content.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -46,6 +45,6 @@ You can create a hierarchical layout with data Source. The following code demons
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/hierarchicallayout-cs2" %}
->Note: If you want to convert the data source into layout, you need to inject DataBinding along with HierarchicalTree module in the diagram.
+>Note: When using DataSource for layout generation, both DataBinding and HierarchicalTree modules must be injected into the diagram.
-
+
diff --git a/ej2-react/diagram/label-appearance.md b/ej2-react/diagram/label-appearance.md
index 0b6f5dadc..64973ac3d 100644
--- a/ej2-react/diagram/label-appearance.md
+++ b/ej2-react/diagram/label-appearance.md
@@ -8,16 +8,19 @@ documentation: ug
domainurl: ##DomainURL##
---
-## Appearance
+# Customizing Label Appearance in React Diagram Component
-You can change the font style of the annotations with the font specific properties [`fontSize`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#fontsize), [`fontFamily`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#fontfamily), [`color`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#color).
-The label’s [`bold`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#bold), [`italic`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#italic), and [`textDecoration`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#textdecoration) properties are used to style the label’s text.
+## Overview
-The label’s [`fill`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#fill), [`strokeColor`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#strokecolor), and [`strokeWidth`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#strokewidth) properties are used to define the background color and border color of the annotation and the [`opacity`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#opacity) property is used to define the transparency of the annotations.
+The React Diagram component provides comprehensive styling options to customize label appearance. Labels can be enhanced with various font properties, colors, decorations, and visual effects to match application requirements.
-The [`visible`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#visibility) property of the annotation enables or disables the visibility of annotation.
+Font styling properties such as [`fontSize`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#fontsize), [`fontFamily`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#fontfamily), [`color`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#color) control the basic text appearance. Additional text formatting is available through [`bold`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#bold), [`italic`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#italic), and [`textDecoration`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#textdecoration) properties are used to style the label’s text.
-The following code illustrates how to customize the appearance of the annotation.
+Background and border styling can be applied using [`fill`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#fill), [`strokeColor`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#strokecolor), and [`strokeWidth`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#strokewidth) properties are used to define the background color and border color of the annotation and the [`opacity`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#opacity) property controls label transparency.
+
+The [`visible`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#visibility) property, which enables or disables label display.
+
+The following code demonstrates comprehensive label appearance customization:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -32,7 +35,7 @@ The following code illustrates how to customize the appearance of the annotation
## Horizontal and vertical alignment
-The following tables illustrates all the possible alignments visually with 'offset (0, 0)'.
+Label positioning within nodes and connectors can be precisely controlled through horizontal and vertical alignment properties. The following table illustrates all possible alignment combinations with offset (0, 0):
| Horizontal Alignment | Vertical Alignment | Output with Offset(0,0) |
| -------- | -------- | -------- |
@@ -46,7 +49,7 @@ The following tables illustrates all the possible alignments visually with 'offs
| Center | Bottom |  |
| Right |Bottom | |
-The following codes illustrates how to align annotations.
+The following code example shows how to configure label alignment:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -61,7 +64,9 @@ The following codes illustrates how to align annotations.
## Annotation Margin
-[`Margin`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#margin) is an absolute value used to add some blank space in any one of its four sides. The annotations can be displaced with the margin property. The following code example illustrates how to align a annotation based on its `offset`, `horizontalAlignment`, `verticalAlignment`, and [`margin`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/) values.
+The [`Margin`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#margin) property adds spacing around labels by specifying absolute values for any or all four sides. This property works in conjunction with offset, horizontal alignment, and vertical alignment to achieve precise label positioning.
+
+The following example demonstrates label positioning using [`margin`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/) values.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -76,12 +81,13 @@ The following codes illustrates how to align annotations.
## Hyperlink
-Diagram provides a support to add a [`hyperlink`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#hyperlink) for the nodes/connectors annotation. It can also be customized with the below properties.
+Labels can include interactive [`hyperlink`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#hyperlink) for both nodes and connectors. Hyperlink behavior and appearance can be customized with several properties.
+
+The [`hyperlinkOpenState`](https://helpej2.syncfusion.com/react/documentation/api/diagram/hyperlinkModel/#hyperlinkopenstate) property controls how the hyperlink opens - in a new window, the same tab, or a new tab.
-A User can open the hyperlink in the new window, the same tab and the new tab by using the [`hyperlinkOpenState`](https://helpej2.syncfusion.com/react/documentation/api/diagram/hyperlinkModel/#hyperlinkopenstate) property.
+Hyperlink appearance is controlled through the [`content`](https://helpej2.syncfusion.com/react/documentation/api/diagram/hyperlinkModel/#content) property for display text, [`color`](https://helpej2.syncfusion.com/react/documentation/api/diagram/hyperlinkModel/#color) for text color, and [`textDecoration`](https://helpej2.syncfusion.com/react/documentation/api/diagram/hyperlinkModel/#textdecoration ) for styling effects like **Underline**, **LineThrough**, **Overline**.
-The [`content`](https://helpej2.syncfusion.com/react/documentation/api/diagram/hyperlinkModel/#content) property of `hyperlink` is used to display the content of the hyper link display text. The [`color`](https://helpej2.syncfusion.com/react/documentation/api/diagram/hyperlinkModel/#color) property of the `hyperlink` is used to display the color of the hyper link.
-The [`textDecoration`](https://helpej2.syncfusion.com/react/documentation/api/diagram/hyperlinkModel/#textdecoration ) property is used to decorate the hyper link text with **Underline**, **LineThrough**, **Overline**. The following example illustrates how to define and customize hyper link in both node and connector.
+The following example shows hyperlink implementation and customization:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -96,8 +102,9 @@ The [`textDecoration`](https://helpej2.syncfusion.com/react/documentation/api/di
## Rotate Annotation
-Annotation can be rotated by setting the [`rotateAngle`](https://helpej2.syncfusion.com/react/documentation/api/diagram/shapeAnnotationModel/#rotateangle) property of the annotation. The following example shows how to rotate annotation text.
+Labels can be rotated to any angle using the [`rotateAngle`](https://helpej2.syncfusion.com/react/documentation/api/diagram/shapeAnnotationModel/#rotateangle) property. This feature is useful for creating dynamic label orientations that match specific design requirements.
+The following example demonstrates label rotation:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
{% include code-snippet/diagram/annotations/es5RotateAngle-cs1/app/index.jsx %}
@@ -115,7 +122,7 @@ Diagram provides template support for annotation. You can either define a string
### String template
- For string template you should define a SVG/HTML content as string in the annotation's [`template`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#template) property.
+ For string template you should define a SVG/HTML content as string in the annotation's `template` property.
The following code illustrates how to define a template in annotation.
@@ -130,13 +137,13 @@ The following code illustrates how to define a template in annotation.
{% previewsample "page.domainurl/code-snippet/diagram/annotations/es5labeltemplate-cs1" %}
-N> For the proper alignment of template, we need to mention width and height for the annotation while using template.
+N> Specify width and height for labels when using templates to ensure proper alignment and rendering.
### Annotation template
-For annotation template you should define a template in html file which you want to render in annotation and assign it to the [`annotationTemplate`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#annotationtemplate) property of diagram. This template can be applied to both nodes and connectors within the diagram.
+HTML-based templates provide more complex content structures by defining templates in separate HTML files. Assign the template to the `annotationTemplate` property of the diagram. This template system works with both nodes and connectors.
-The following code illustrates how to define a annotationTemplate in annotation for nodes and connectors.
+The following code demonstrates HTML template usage for labels:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -168,7 +175,9 @@ The following code illustrates how to define a functional template.
## Text align
-The [`textAlign`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#textalign) property of annotation allows you to set how the text should be aligned (left, right, center, or justify) inside the text block. The following codes illustrate how to set textAlign for an annotation.
+The [`textAlign`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#textalign) property controls text alignment within the label boundaries. Available alignment options include left, right, center, and justify, providing flexibility for various content layouts.
+
+The following code demonstrates text alignment configuration:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -192,7 +201,9 @@ The following table shows the different text alignment.
## Text Wrapping
-When text overflows node boundaries, you can control it by using [`text wrapping`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#textwrapping). So, it is wrapped into multiple lines. The wrapping property of annotation defines how the text should be wrapped. The following code illustrates how to wrap a text in a node.
+When label text exceeds node or connector boundaries, the [`text wrapping`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#textwrapping)property controls how content is handled. Text can be wrapped into multiple lines based on the specified wrapping behavior.
+
+The following code shows text wrapping implementation:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -209,15 +220,17 @@ When text overflows node boundaries, you can control it by using [`text wrapping
| -------- | -------- | -------- |
| No Wrap | Text will not be wrapped. |  |
| Wrap | Text-wrapping occurs, when the text overflows beyond the available node width. |  |
-| WrapWithOverflow (Default) | Text-wrapping occurs, when the text overflows beyond the available node width. However, the text may overflow beyond the node width in the case of a very long word. |  |
+| WrapWithOverflow (Default) | Text wrapping occurs with overflow allowed for very long words that cannot be broken. |  |
## Text overflow
-The label’s [`TextOverflow`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#textoverflow) property is used control whether to display the overflowed content in node or not.
+The label’s [`TextOverflow`](https://helpej2.syncfusion.com/react/documentation/api/diagram/textStyleModel/#textoverflow) property manages content display when text exceeds the available label space. This property works in conjunction with text wrapping to provide comprehensive text handling.
+
+Available overflow options include:
-- `Clip` - The text which overflowing node's bounds will be removed.
-- `Ellipsis` - The text which overflowing nodes's bounds will be replaced by three dots.
-- `Wrap` - Entire text will be rendered overflowing in y-axis and wrapped in x-axis.
+- **Clip** - Overflowing content beyond node boundaries is removed.
+- **Ellipsis** - Overflowing content is replaced with three dots (...).
+- **Wrap** - Content renders with vertical overflow and horizontal wrapping.
Types of text overflow are shown in below table.
diff --git a/ej2-react/diagram/label-events.md b/ej2-react/diagram/label-events.md
index 08e733639..68d18eeba 100644
--- a/ej2-react/diagram/label-events.md
+++ b/ej2-react/diagram/label-events.md
@@ -1,25 +1,30 @@
---
layout: post
title: Label Events in React Diagram component | Syncfusion®
-description: Learn here all about Labels in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+description: Learn about annotation events in Syncfusion React Diagram component including keyDown, keyUp, doubleClick, textEdit, and selectionChange events with examples.
control: Label Events
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Annotation events.
+# Handling Annotation Events in Diagram Component
-There are some events which will trigger while interacting with annotation.
-* KeyDown.
-* KeyUp.
-* DoubleClick.
-* TextEdit.
+Annotations in React Diagram components are text labels that can be added to nodes and connectors to provide additional information. When users interact with these annotations, various events are triggered that allow developers to customize behavior and respond to user actions.
-## KeyDown event
+The diagram component provides several annotation-related events that fire during different interaction scenarios:
+- **KeyDown** - Triggered when any key is pressed while an annotation is focused.
+- **KeyUp** - Triggered when a pressed key is released while an annotation is focused.
+- **DoubleClick** - Triggered when double-clicking on annotations, nodes, connectors, or diagram surface.
+- **TextEdit** - Triggered when annotation text editing is completed and focus is lost.
+- **SelectionChange** - Triggered when annotations are selected or deselected.
-The [`keyDown`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iKeyEventArgs/) event is triggered whenever any key is pressed. The following example shows how to capture the keyDown event and modify the fill color of a node on each key press:
+## KeyDown Event
+
+The [`keyDown`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iKeyEventArgs/) event triggers whenever any key is pressed while interacting with the diagram. This event provides access to key information and allows modification of diagram elements based on keyboard input.
+
+The event arguments include details about the pressed key, modifier keys, and the current diagram state. The following example demonstrates capturing the keyDown event to modify a node's fill color with each key press:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -32,9 +37,11 @@ The [`keyDown`](https://helpej2.syncfusion.com/react/documentation/api/diagram/i
{% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Event-cs1" %}
-## KeyUp event
+## KeyUp Event
-The [`keyUp`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iKeyEventArgs/) event is triggered whenever we press and release any key. The following example shows how to capture the keyUp event and modify the fill color of a node on each key press:
+The [`keyUp`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iKeyEventArgs/) event triggers when a pressed key is released. This event is useful for handling scenarios where the complete key press cycle (press and release) needs to be captured, such as implementing keyboard shortcuts or text input validation.
+
+Unlike the keyDown event, keyUp ensures that the key action has been fully completed. The following example shows how to capture the keyUp event and modify the fill color of a node:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -47,9 +54,11 @@ The [`keyUp`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iKe
{% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Event-cs2" %}
-## Double click event
+## Double Click Event
+
+The [`doubleClick`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iDoubleClickEventArgs/) event triggers when users double-click on nodes, connectors, or the diagram surface. This interaction automatically activates annotation editing mode for the clicked element, allowing users to modify text content directly.
-The [`doubleClick`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iDoubleClickEventArgs/) event is triggered when you double-click on a node, connector, or the diagram surface. Double-clicking on a diagram element activates the annotation editing mode. The following code example shows how to capture the [`doubleClick`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iDoubleClickEventArgs/) event:
+The event provides information about the clicked element, mouse position, and current selection state. Developers can use this event to implement custom behaviors or prevent default annotation editing when needed:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -62,9 +71,11 @@ The [`doubleClick`](https://helpej2.syncfusion.com/react/documentation/api/diagr
{% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Event-cs3" %}
-## TextEdit event
+## TextEdit Event
-The [`textEdit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iTextEditEventArgs/) event triggers when you finish editing the annotation text and the focus is removed from the annotation text.
+The [`textEdit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iTextEditEventArgs/) event triggers when annotation text editing is completed and focus moves away from the text editor. This event occurs after users finish modifying annotation content and provides access to both the old and new text values.
+
+This event is particularly useful for implementing text validation, formatting, or saving changes to external data sources:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -77,7 +88,9 @@ The [`textEdit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/
{% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Event-cs4" %}
-You can prevent adding new text to the annotation by setting the `cancel` property of [`textEdit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iTextEditEventArgs/) to true.
+### Preventing Text Changes
+
+The textEdit event allows prevention of text modifications by setting the `cancel` property to **true**. This is useful for implementing validation rules or maintaining read-only annotations:
``` javascript
textEdit: function (args) {
@@ -87,11 +100,15 @@ textEdit: function (args) {
```
-## Selection change event
+## Selection Change Event
+
+The [`selectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#selectionchange) event triggers when annotations of nodes or connectors are selected or deselected within the diagram. This event provides detailed information about the selection state changes and affected elements.
+
+The event is useful for implementing custom selection behaviors, updating property panels, or synchronizing selection state with other application components.
-The [`selectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#selectionchange) event is triggered when an annotation of a node or connector is selected in the diagram.
+### Preventing Selection
-You can prevent selection by setting the `cancel` property of [`SelectionChangeEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/iselectionchangeeventargs/) to true, as shown in the code snippet below.
+Selection can be prevented by setting the `cancel` property of [`SelectionChangeEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/iselectionchangeeventargs/) to **true** during the selection change process:
```javascript
selectionChange: function (args) {
diff --git a/ej2-react/diagram/label-interaction.md b/ej2-react/diagram/label-interaction.md
index 46dc8c116..1dd69727b 100644
--- a/ej2-react/diagram/label-interaction.md
+++ b/ej2-react/diagram/label-interaction.md
@@ -1,16 +1,16 @@
---
layout: post
title: Label Interaction in React Diagram component | Syncfusion®
-description: Learn here all about Labels in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+description: Learn how to enable interactive label features in Syncfusion® React Diagram including selection, dragging, rotation, resizing, editing, and drag limits.
control: Label Interaction
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-## Annotation Interactions
+# Interactive Label Features
-Diagram allows annotation to be interacted by selecting, dragging, rotating, and resizing. Annotation interaction is disabled, by default. You can enable annotation interaction with the `constraints` property of annotation. You can also curtail the services of interaction by enabling either selecting, dragging, rotating, or resizing individually with the respective constraints property of annotation. The following code illustrates how to enable interactive mode.
+The Diagram component allows labels to be interactive through selecting, dragging, rotating, and resizing operations. Label interaction is disabled by default. Enable label interaction using the `constraints` property of the label. You can also control specific interaction types by enabling individual constraints for selecting, dragging, rotating, or resizing. The following code demonstrates how to enable interactive mode.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -25,76 +25,77 @@ Diagram allows annotation to be interacted by selecting, dragging, rotating, and
## Constraints
-The [`constraints`](https://ej2.syncfusion.com/react/documentation/diagram/constraints#annotation-constraints) property of annotation allows you to enable/disable certain annotation behaviors.
+The [`constraints`](https://ej2.syncfusion.com/react/documentation/diagram/constraints#annotation-constraints) property of labels allows enabling or disabling specific label behaviors. Use these constraints to control which interaction types are available for each label.
-## Annotation rotation
+## Label Editing
-The [`rotationReference`](https://helpej2.syncfusion.com/react/documentation/api/diagram/shapeAnnotationModel/#rotationreference) property of an annotation allows you to control whether the text should rotate relative to its parent node or the Page. The following code examples illustrate how to configure rotationReference for an annotation.
+The Diagram component supports editing labels at runtime, both programmatically and interactively. By default, labels are in view mode. Labels can be switched to edit mode using two approaches:
+
+### Programmatic Editing
+By using [`startTextEdit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#starttextedit) method to programmatically enter edit mode for a specific label.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
-{% include code-snippet/diagram/annotations/es5Rotation-cs1/app/index.jsx %}
+{% include code-snippet/diagram/annotations/es5Opacity-cs1/app/index.jsx %}
{% endhighlight %}
{% highlight ts tabtitle="index.tsx" %}
-{% include code-snippet/diagram/annotations/es5Rotation-cs1/app/index.tsx %}
+{% include code-snippet/diagram/annotations/es5Opacity-cs1/app/index.tsx %}
{% endhighlight %}
{% endtabs %}
- {% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Rotation-cs1" %}
+ {% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Opacity-cs1" %}
-| Value | Description | Image |
-| -------- | -------- | -------- |
-| Page | When this option is set, the annotation remains fixed in its original orientation even if its parent node is rotated. |  |
-| Parent | In this case, the annotation rotates along with its parent node. | |
+### Interactive Editing
+Labels can be edited interactively through user actions:
+1. Double-clicking the label.
+2. Selecting the item and pressing the F2 key.
+
+Double-clicking any label enables editing mode. When the editor loses focus, the label content is updated. The [`doubleClick`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#doubleclick) event triggers when double-clicking on nodes, connectors, or the diagram canvas.
-### Read-only annotations
+## Label Rotation
-Diagram allows to create read-only annotations. You have to set the read-only constraints to the annotation's [`constraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#constraints) property. The following code illustrates how to enable read-only mode.
+The [`rotationReference`](https://helpej2.syncfusion.com/react/documentation/api/diagram/shapeAnnotationModel/#rotationreference) property controls whether labels rotate relative to their parent node or remain fixed relative to the page. The following code examples demonstrate how to configure rotationReference for labels.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
-{% include code-snippet/diagram/annotations/es5Read-cs1/app/index.jsx %}
+{% include code-snippet/diagram/annotations/es5Rotation-cs1/app/index.jsx %}
{% endhighlight %}
{% highlight ts tabtitle="index.tsx" %}
-{% include code-snippet/diagram/annotations/es5Read-cs1/app/index.tsx %}
+{% include code-snippet/diagram/annotations/es5Rotation-cs1/app/index.tsx %}
{% endhighlight %}
{% endtabs %}
- {% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Read-cs1" %}
+ {% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Rotation-cs1" %}
-## Edit
+| Value | Description | Image |
+| -------- | -------- | -------- |
+| Page | When this option is set, the annotation remains fixed in its original orientation even if its parent node is rotated. |  |
+| Parent | In this case, the annotation rotates along with its parent node. | |
-Diagram provides support to edit an annotation at runtime, either programmatically or interactively. By default, annotation is in view mode. But it can be brought to edit mode in two ways;
+## Read-only Labels
-### Programmatically
-By using [`startTextEdit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#starttextedit) method, edit the text through programmatically.
+The Diagram component supports creating read-only labels that cannot be edited by users. Set the read-only constraint in the label's [`constraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#constraints) property. The following code demonstrates how to enable read-only mode.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
-{% include code-snippet/diagram/annotations/es5Opacity-cs1/app/index.jsx %}
+{% include code-snippet/diagram/annotations/es5Read-cs1/app/index.jsx %}
{% endhighlight %}
{% highlight ts tabtitle="index.tsx" %}
-{% include code-snippet/diagram/annotations/es5Opacity-cs1/app/index.tsx %}
+{% include code-snippet/diagram/annotations/es5Read-cs1/app/index.tsx %}
{% endhighlight %}
{% endtabs %}
- {% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Opacity-cs1" %}
-
-### Interactively
- 1. By double-clicking the annotation.
- 2. By selecting the item and pressing the F2 key.
-
-Double-clicking any annotation will enables editing mode. When the focus of editor is lost, the annotation for the node is updated. When you double-click on the node/connector/diagram model, the [`doubleClick`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#doubleclick) event gets triggered.
+ {% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Read-cs1" %}
-## Drag Limit
+## Drag Limits
-* The diagram control now supports defining the [`dragLimit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#draglimit) to the label while dragging from the connector and also update the position to the nearest segment offset.
+The diagram control supports defining [`dragLimit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#draglimit) properties for connector labels to restrict dragging within specified boundaries. The drag limit automatically updates the label position to the nearest segment offset when dragging.
-* You can set the value to dragLimit [`left`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/#left), [`right`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/#right), [`top`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/#top), and [`bottom`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/#bottom) properties which allow the dragging of connector labels to a certain limit based on the user defined values.
+Configure drag limit boundaries using the [`left`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/#left), [`right`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/#right), [`top`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/#top), and [`bottom`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/#bottom) properties. These properties limit connector label dragging based on user-defined values.
-* By default, drag limit will be disabled for the connector. It can be enabled by setting connector constraints as drag.
+Drag limits are disabled by default for connectors. Enable drag limits by setting the connector constraints to include drag functionality.
-* The following code illustrates how to set a dragLimit for connector annotations.
+The following code demonstrates how to configure dragLimit for connector labels:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -107,9 +108,9 @@ Double-clicking any annotation will enables editing mode. When the focus of edit
{% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Interaction-cs2" %}
-## Multiple annotations
+## Multiple Labels
-You can add any number of annotations to a node or connector. The following code illustrates how to add multiple annotations to a node and connector.
+Nodes and connectors support multiple labels. Each label can have independent properties and constraints. The following code demonstrates how to add multiple labels to nodes and connectors.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/labels.md b/ej2-react/diagram/labels.md
index 9aa4b0396..27bf7cc65 100644
--- a/ej2-react/diagram/labels.md
+++ b/ej2-react/diagram/labels.md
@@ -8,15 +8,15 @@ documentation: ug
domainurl: ##DomainURL##
---
-# Labels in React Diagram component
+# Labels in React Diagram Component
-[`Annotation`](https://ej2.syncfusion.com/react/documentation/api/diagram/annotationModel) is a block of text that can be displayed over a node or connector. Annotation is used to textually represent an object with a string that can be edited at runtime. Multiple annotations can be added to a node/connector.
+[`Annotation`](https://ej2.syncfusion.com/react/documentation/api/diagram/annotationModel) is a block of text that can be displayed over a node or connector. Annotations are used to textually represent an object with a string that can be edited at runtime. Multiple annotations can be added to a node or connector.
-## Create annotation
+## Create Annotations
-An annotation can be added to a node/connector by defining the annotation object and adding that to the annotation collection of the node/connector. The [`content`](https://ej2.syncfusion.com/react/documentation/api/diagram/annotationModel#content) property of annotation defines the text to be displayed. The following code illustrates how to create a annotation.
+An annotation can be added to a node or connector by defining the annotation object and adding it to the annotations collection of the node or connector. The [`content`](https://ej2.syncfusion.com/react/documentation/api/diagram/annotationModel#content) property of the annotation defines the text to be displayed. The following code illustrates how to create an annotation.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -29,15 +29,13 @@ An annotation can be added to a node/connector by defining the annotation object
{% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Annotation-cs1" %}
-N> When setting a Annotation's ID, ensure that it does not contain white spaces, does not start with numbers or special characters, and does not include special characters like underscores (_) or spaces.
-
-N> When setting a Annotation's ID, ensure that it does not contain white spaces, does not start with numbers or special characters, and does not include special characters like underscores (_) or spaces.
+N> When setting an Annotation's ID, ensure that it does not contain white spaces, does not start with numbers or special characters, and does not include special characters like underscores (_) or spaces.
## Add annotations at runtime
-Annotations can be added at runtime by using the diagram method [`addLabels`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addlabels). The following code illustrates how to add a annotation to a node.
+Annotations can be added at runtime by using the client-side method [`addLabels`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addlabels). The following code illustrates how to add an annotation to a node.
-The annotation's [`id`](https://ej2.syncfusion.com/react/documentation/api/diagram/annotationModel#id) property is used to define the name of the annotation and its further used to find the annotation at runtime and do any customization.
+The annotation's [`id`](https://ej2.syncfusion.com/react/documentation/api/diagram/annotationModel#id) property is used to define the name of the annotation and is further used to find the annotation at runtime and perform any customization.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -50,34 +48,36 @@ The annotation's [`id`](https://ej2.syncfusion.com/react/documentation/api/diagr
{% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Run-cs1" %}
-## Remove annotation
+## Update annotations at runtime
+
+Annotations can be updated directly by accessing the annotation from the node's annotations collection property and modifying any annotation properties at runtime. To reflect the changes immediately, call the `dataBind` method.
-A collection of annotations can be removed from the node by using diagram method [`removeLabels`](https://ej2.syncfusion.com/react/documentation/api/diagram/#removelabels). The following code illustrates how to remove a annotation to a node.
+The following code example illustrates how to change the annotation properties.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
-{% include code-snippet/diagram/annotations/es5Update-cs1/app/index.jsx %}
+{% include code-snippet/diagram/annotations/es5Update-cs2/app/index.jsx %}
{% endhighlight %}
{% highlight ts tabtitle="index.tsx" %}
-{% include code-snippet/diagram/annotations/es5Update-cs1/app/index.tsx %}
+{% include code-snippet/diagram/annotations/es5Update-cs2/app/index.tsx %}
{% endhighlight %}
{% endtabs %}
- {% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Update-cs1" %}
+ {% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Update-cs2" %}
-## Update annotation at runtime
-You can get the annotation directly from the node’s annotations collection property and you can change any annotation properties at runtime. To reflect the changes immediately, we need to call `dataBind`.
+## Remove annotations
-The following code example illustrates how to change the annotation properties.
+A collection of annotations can be removed from the node by using the diagram method [`removeLabels`](https://ej2.syncfusion.com/react/documentation/api/diagram/#removelabels). The following code illustrates how to remove an annotation from a node.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
-{% include code-snippet/diagram/annotations/es5Update-cs2/app/index.jsx %}
+{% include code-snippet/diagram/annotations/es5Update-cs1/app/index.jsx %}
{% endhighlight %}
{% highlight ts tabtitle="index.tsx" %}
-{% include code-snippet/diagram/annotations/es5Update-cs2/app/index.tsx %}
+{% include code-snippet/diagram/annotations/es5Update-cs1/app/index.tsx %}
{% endhighlight %}
{% endtabs %}
- {% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Update-cs2" %}
+ {% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Update-cs1" %}
+
diff --git a/ej2-react/diagram/lane.md b/ej2-react/diagram/lane.md
index 822ea8e1e..643be1892 100644
--- a/ej2-react/diagram/lane.md
+++ b/ej2-react/diagram/lane.md
@@ -1,20 +1,22 @@
---
layout: post
-title: Lane in React Diagram component | Syncfusion®
-description: Learn here all about Swim lane in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Lane in React Diagram Component | Syncfusion®
+description: Learn here all about Swim lane in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Lane
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-## Lanes
+# Lane Management in React Diagram Component
-Lane is a functional unit or a responsible department of a business process that helps to map a process within the functional unit or in between other functional units.
+## Overview
-The number of [`lanes`](https://ej2.syncfusion.com/react/documentation/api/diagram/laneModel) can be added to swimlane. The lanes are automatically stacked inside swimlane based on the order they are added.
+A lane is a functional unit or responsible department of a business process that helps to map a process within the functional unit or between other functional units. In swimlane diagrams, lanes represent different actors, departments, or systems that participate in the process workflow.
-### Create an empty lane
+The number of [`lanes`](https://ej2.syncfusion.com/react/documentation/api/diagram/laneModel) can be added to a swimlane. The lanes are automatically stacked inside the swimlane based on the order they are added.
+
+### Create an Empty Lane
* The lane `id` is used to define the name of the lane and its further used to find the lane at runtime and do any customization.
@@ -31,7 +33,7 @@ The following code example illustrates how to define a swimlane with lane.
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5Emptylane-cs1" %}
-### Create lane header
+### Create Lane Header
* The [`header`](https://ej2.syncfusion.com/react/documentation/api/diagram/laneModel#header) property of lane allows you to textually describe the lane and to customize the appearance of the description.
@@ -48,7 +50,7 @@ The following code example illustrates how to define a lane header.
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5Laneheader-cs1" %}
-### Customizing lane and lane header
+### Customizing Lane and Lane Header
* The size of lane can be controlled by using [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel#height) properties of lane.
@@ -69,9 +71,9 @@ The following code example illustrates how to customize the lane header.
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5Laneheadercustomize-cs1" %}
-#### Dynamic customization of lane header
+#### Dynamic Customization of Lane Header
-You can customize the lane header style and text properties dynamically. The following code illustrates how to dynamically customize the lane header.
+Lane header style and text properties can be customized dynamically. The following code illustrates how to dynamically customize the lane header.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -84,9 +86,9 @@ You can customize the lane header style and text properties dynamically. The fol
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5Dynamiclaneheader-cs1" %}
-### Add/remove lane at runtime
+### Add and Remove Lanes at Runtime
-You can add the a lanes at runtime by using the [`addLanes`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addlanes) method and remove lane at runtime using the [`removeLane`](https://ej2.syncfusion.com/react/documentation/api/diagram/#removelane) method. The following code illustrates how to dynamically add and remove lane in swimlane.
+Lanes can be added at runtime by using the [`addLanes`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addlanes) method and remove lane at runtime using the [`removeLane`](https://ej2.syncfusion.com/react/documentation/api/diagram/#removelane) method. The following code illustrates how to dynamically add and remove lane in swimlane.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -99,9 +101,9 @@ You can add the a lanes at runtime by using the [`addLanes`](https://ej2.syncfus
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5PhaseCustomize-cs1" %}
-### Add children to lane
+### Add Children to Lane
-To add nodes to lane,you should add [`children`](https://ej2.syncfusion.com/react/documentation/api/diagram/laneModel#children) collection of the lane.
+To add nodes to a lane, you should add them to the [`children`](https://ej2.syncfusion.com/react/documentation/api/diagram/laneModel#children) collection of the lane.
The following code example illustrates how to add nodes to lane.
@@ -116,7 +118,7 @@ The following code example illustrates how to add nodes to lane.
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5Lanechildern-cs1" %}
-#### Add child dynamically into the lane.
+#### Add Child Dynamically into the Lane.
The child node can be inserted into the lane at runtime by using the [`addNodetoLane`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addnodetolane) method.
@@ -131,13 +133,13 @@ The child node can be inserted into the lane at runtime by using the [`addNodeto
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5Lanechildren-cs2" %}
-We can also drag nodes from palette or diagram and drop it inside the lane.
+Nodes can also be dragged from the palette or diagram and dropped inside the lane.

-### Prevent child movement outside lane
+### Prevent Child Movement Outside Lane
-To prevent child nodes from moving outside their designated lanes, you can use specific constraints. By default, nodes are allowed to move freely. To restrict their movement, you need to set the constraints accordingly.
+To prevent child nodes from moving outside their designated lanes, specific constraints can be used. By default, nodes are allowed to move freely. To restrict their movement, the constraints need to be set accordingly.
Here is an example of how to apply these constraints:
@@ -152,9 +154,9 @@ Here is an example of how to apply these constraints:
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5Lanechildren-cs3" %}
-### AddInfo
+### Additional Information Storage
-AddInfo for lanes similar to the nodes. we can store additional information about the specific lane by using the [`addInfo`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addinfo).
+Additional information storage for lanes is similar to nodes. Additional information about a specific lane can be stored by using the [`addInfo`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addinfo) property.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -167,23 +169,24 @@ AddInfo for lanes similar to the nodes. we can store additional information abou
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5Lanechildren-cs4" %}
-### Lane interaction
+### Lane Interaction
-#### Resizing lane
+#### Resizing Lane
-* Lane can be resized in the bottom and left direction.
-* Lane can be resized by using resize selector of the lane.
-* Once you resize the lane, the swimlane will be resized automatically.
-* The lane can be resized either resizing the selector or the tight bounds of the child object. If the child node move to edge of the lane it can be automatically resized. The following image illustrates how resize the lane. 
+* Lanes can be resized in the bottom and left directions.
+* Lanes can be resized by using the resize selector of the lane.
+* Once a lane is resized, the swimlane will be resized automatically.
+* The lane can be resized either by using the resize selector or the tight bounds of the child object. If the child node moves to the edge of the lane,it can be automatically resized. The following image illustrates how to resize the lane.
+
-#### Lane swapping
+#### Lane Swapping
-* Lanes can be swapped using drag the lanes over another lane.
-* Helper should intimate the insertion point while lane swapping. The following image illustrates how swapping the lane. 
+* Lanes can be swapped by dragging the lanes over another lane.
+* A helper should indicate the insertion point while lane swapping. The following image illustrates how to swap lanes. 
-#### Disable Swimlane Lane swapping
+#### Disable Swimlane Lane Swapping
-You can disable swimlane lane swapping by using the property called `canMove`..
+Swimlane lane swapping can be disabled by using the property called `canMove`.
The following code illustrates how to disable swimlane lane swapping.
@@ -198,24 +201,28 @@ The following code illustrates how to disable swimlane lane swapping.
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5PhaseCustomize-cs2" %}
-#### Resize helper
+#### Resize Helper
+
+* A special resize helper will be used to resize the lanes.
+* The resize cursor will be available on the left and bottom directions only.
+* Once the lane is resized, the swimlane will be resized automatically.
+
+#### Children Interaction in Lanes
-* The special resize helper will be used to resize the lanes.
-* The resize cursor will be available on the left and bottom direction alone.
-* Once resize the lane the swimlane will be resized automatically.
+* Child nodes can be resized within swimlanes.
+* Child nodes can be dragged within lanes.
+* Child nodes can be interchanged from one lane to another lane.
+* Child nodes can be dragged and dropped from lanes to the diagram.
+* Child nodes can be dragged and dropped from the diagram to lanes.
+* Based on the child node interactions, the lane size should be updated.
-#### Children interaction in lanes
+The following image illustrates children interaction in lanes.
-* You can resize the child node within swimlanes.
-* You can drag the child nodes within lane.
-* Interchange the child nodes from one lane to another lane.
-* Drag and drop the child nodes from lane to diagram.
-* Drag and drop the child nodes from diagram to lane.
-* Based on the child node interactions,the lane size should be updated.
-The following image illustrates children interaction in lane. 
+
-#### Lane header editing
+#### Lane Header Editing
-Diagram provides the support to edit Lane headers at runtime. We achieve the header editing by double click event. Double clicking the header label will enables the editing of that.
-The following image illustrates how to edit the lane header. 
+The diagram provides support to edit lane headers at runtime. Header editing is achieved by double-click events. Double-clicking the header label will enable the editing of that header.
+The following image illustrates how to edit the lane header.
+
diff --git a/ej2-react/diagram/layers.md b/ej2-react/diagram/layers.md
index a18b111f4..e64d2424c 100644
--- a/ej2-react/diagram/layers.md
+++ b/ej2-react/diagram/layers.md
@@ -1,29 +1,33 @@
---
layout: post
-title: Layers in React Diagram component | Syncfusion®
-description: Learn here all about Layers in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Layers in React Diagram Component | Syncfusion®
+description: Learn here all about Layers in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Layers
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Layers in React Diagram component
+# Layers in React Diagram Component
-**Layer** organizes related shapes within a diagram control as named categories. Assigning shapes to different layers enables selective viewing, removal, and locking of distinct shape categories.
+**Layers** provide a powerful organizational system for managing diagram elements by grouping related shapes into named categories. This functionality enables developers to build complex diagrams with selective viewing, interaction control, and bulk property management across multiple elements simultaneously.
-In a diagram, [Layers](https://ej2.syncfusion.com/react/documentation/api/diagram/layerModel/) facilitate the modification of properties for all shapes assigned to a specific layer. Key properties that can be configured include:
+## Core Layer Properties
-* Objects
-* Visible
-* Lock
-* AddInfo
+In a diagram, [Layers](https://ej2.syncfusion.com/react/documentation/api/diagram/layerModel/) enable modification of properties for all shapes assigned to a specific layer. The primary configurable properties include:
+
+* **Objects** - Define which elements belong to the layer.
+* **Visible** - Control layer visibility.
+* **Lock** - Prevent interactions with layer elements.
+* **AddInfo** - Store additional custom information.
## Objects
-The layer's [objects](https://ej2.syncfusion.com/react/documentation/api/diagram/layer/#objects) property specifies which diagram elements belong to that layer. This property contains a collection where you can define the categories of nodes and connectors that the layer encompasses.
+The layer's [objects](https://ej2.syncfusion.com/react/documentation/api/diagram/layer/#objects) property specifies which diagram elements belong to that layer. This property contains a collection of element IDs that defines the categories of nodes and connectors the layer encompasses.
+
+**Use case**: Separate different types of diagram elements for independent management - for example, keeping background elements in one layer and interactive elements in another.
-In the following example, the basic shapes are categorized in layer 1, and the flow shapes are categorized in layer 2.
+In the following example, basic shapes are categorized in layer 1, and flow shapes are categorized in layer 2:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -39,9 +43,11 @@ In the following example, the basic shapes are categorized in layer 1, and the f
## Visible
-The layer's [visible](https://ej2.syncfusion.com/react/documentation/api/diagram/layer/#visible) property is used to control the visibility of the elements assigned to the layer. You can hide objects in one layer while showing objects in another layer.
+The layer's [visible](https://ej2.syncfusion.com/react/documentation/api/diagram/layer/#visible)property controls the visibility of all elements assigned to the layer. This allows selective display of different diagram sections without removing elements permanently.
+
+**Use case**: Create diagrams with multiple views where users can toggle between different information layers, such as showing only critical path items in a project diagram.
-In the following example, the visibility of layer one is set to false. By default, the `visible` property of a layer is set to **true**.
+In the following example, the visibility of layer one is set to false. By default, the `visible` property of a layer is set to **true**:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -56,9 +62,11 @@ In the following example, the visibility of layer one is set to false. By defaul
## Lock
-The layer's [lock](https://ej2.syncfusion.com/react/documentation/api/diagram/layer/#lock) property is used to prevent or allow changes to the element's dimensions and positions. Locking a layer prevents any interactions with the objects in that layer, such as selecting, dragging, rotating, and connecting.
+The layer's [lock](https://ej2.syncfusion.com/react/documentation/api/diagram/layer/#lock) property prevents or allows changes to element dimensions and positions. When a layer is locked, all interactions with objects in that layer are disabled, including selecting, dragging, rotating, and connecting operations.
-In the following example the objects in layer one is locked. By default, the `lock` property of a layer is set to **false**.
+**Use case**: Protect template elements or background graphics from accidental modification while allowing users to work with other diagram elements.
+
+In the following example, the objects in layer one are locked. By default, the `lock` property of a layer is set to **false**:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -75,9 +83,11 @@ In the following example the objects in layer one is locked. By default, the `lo
## AddInfo
-The [`addInfo`](https://ej2.syncfusion.com/react/documentation/api/diagram/layer/#addinfo) property of layers allow you to maintain additional information to the layers.
+The [`addInfo`](https://ej2.syncfusion.com/react/documentation/api/diagram/layer/#addinfo) property allows storage of additional custom information with layers. This can be useful for storing metadata, configuration settings, or application-specific data associated with the layer.
+
+**Use case**: Store layer descriptions, creation timestamps, owner information, or custom application data for enhanced layer management.
-The following code illustrates how to add additional information to the layers.
+The following code illustrates how to add additional information to layers:
```ts
@@ -155,7 +165,7 @@ root.render();
```
-### Add layer at runtime
+## Add Layer at Runtime
Layers can be added at runtime using the [`addLayer`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addlayer) public method.
@@ -175,7 +185,7 @@ The following code illustrates how to add a new layer with new connectors stored
{% previewsample "page.domainurl/code-snippet/diagram/layers/layers-cs4" %}
-### Remove layer at runtime
+## Remove Layer at Runtime
Layers can be removed at runtime by using the [`removeLayer`](https://ej2.syncfusion.com/react/documentation/api/diagram/#removelayer) public method.
@@ -195,7 +205,7 @@ The following code illustrates how to remove a layer.
{% previewsample "page.domainurl/code-snippet/diagram/layers/layers-cs5" %}
-### moveObjects
+### MoveObjects
You can move objects from one layer to another dynamically using the [`moveObjects`](https://ej2.syncfusion.com/react/documentation/api/diagram/#moveobjects) public method of the diagram control. This can be useful for managing complex diagrams with multiple layers where you need to update the categorization of elements based on user interaction or other dynamic conditions.
@@ -214,12 +224,12 @@ The following code illustrates how to move objects from one layer to another lay
## Z-Index
-[`zIndex`](https://ej2.syncfusion.com/react/documentation/api/diagram/layer/#zindex) property of a layer defines its Z order within the diagram. This property allows you to control the layer's position in the stacking order. You can adjust the layer's z-index by moving it forward or backward relative to other layers in the diagram.
+[`zIndex`](https://ej2.syncfusion.com/react/documentation/api/diagram/layer/#zindex) property of a layer defines its position in the stacking order within the diagram. Higher z-index values render above lower values, allowing control over which layers appear in front of others.
-### bringLayerForward
+### Bring Layer Forward
-Layers can be moved forward at runtime by using the [`bringLayerForward`](https://ej2.syncfusion.com/react/documentation/api/diagram/#bringlayerforward) public method.
+Move a layer forward in the stacking order using the [`bringLayerForward`](https://ej2.syncfusion.com/react/documentation/api/diagram/#bringlayerforward) public method.
The following code illustrates how to bring forward to layer.
@@ -230,9 +240,9 @@ diagram.bringLayerForward('layer1');
```
-### sendLayerBackward
+### Send Layer Backward
-Layers can be moved backward at runtime by using the [`sendLayerBackward`](https://ej2.syncfusion.com/react/documentation/api/diagram/#sendlayerbackward) public method.
+Move a layer backward in the stacking order using the [`sendLayerBackward`](https://ej2.syncfusion.com/react/documentation/api/diagram/#sendlayerbackward) public method.
```ts
@@ -254,15 +264,17 @@ The following code illustrates how to send the layer forward/backward to another
{% previewsample "page.domainurl/code-snippet/diagram/layers/layers-cs7" %}
-### Layer and objects rendering order
+### Layer and Objects Rendering Order
The rendering of diagram elements with layer properties involves grouping them within a `diagram_diagramLayer` for basic shape nodes and `diagram_nativeLayer_svg` for SVG-native elements. Even if different types of nodes are added within the same layer, the rendering at the DOM level occurs in separate layers. Therefore, when executing layering commands like [`bringLayerForward`](https://ej2.syncfusion.com/react/documentation/api/diagram/#bringlayerforward) and [`sendLayerBackward`](https://ej2.syncfusion.com/react/documentation/api/diagram/#sendlayerbackward), the native SVG elements will always render above the basic shape elements.
The order of rendering is as follows: HTML shapes -> SVG shapes -> Path data shapes & Basic shapes.
-## cloneLayer
+## Clone Layer
+
+Layers can be cloned with its object by using the [`cloneLayer`](https://ej2.syncfusion.com/react/documentation/api/diagram/#clonelayer) public method.This creates an identical copy of the layer and all its assigned elements.
-Layers can be cloned with its object by using the [`cloneLayer`](https://ej2.syncfusion.com/react/documentation/api/diagram/#clonelayer) public method.
+**Use case**: Create template layers or duplicate complex layer configurations for reuse in different diagram sections.
The following code illustrates how clone the layer.
@@ -277,15 +289,15 @@ The following code illustrates how clone the layer.
{% previewsample "page.domainurl/code-snippet/diagram/layers/layers-cs8" %}
-## Active layer
+## Active Layer
-Active Layer refers to the layer with the highest z-index in a diagram compared to other layers. When adding objects at runtime, they are stored in this active layer. If no layers are explicitly defined in the diagram, a default layer is created and automatically set as the active layer. However, when multiple layers are defined, the layer with the highest z-index takes precedence as the active layer.
+The active layer represents the layer with the highest z-index in a diagram. When objects are added at runtime, they are automatically assigned to the active layer. If no layers are explicitly defined, a default layer is created and set as the **active layer**. When multiple layers exist, the layer with the highest z-index becomes the active layer.
-Public methods are available to get and set the active layer, which are explained below.
+**Use case**: Ensure new elements are added to the appropriate layer in multi-layer diagrams, particularly in interactive editing scenarios.
### Get ActiveLayer
-Active layer of the diagram can be retrieved by using the[`getActiveLayer`](https://ej2.syncfusion.com/react/documentation/api/diagram/#getactivelayer) public method.
+Retrieve the current active layer of the diagram using the [`getActiveLayer`](https://ej2.syncfusion.com/react/documentation/api/diagram/#getactivelayer) public method.
The following code illustrates how fetch active layer from the diagram
diff --git a/ej2-react/diagram/layout-customization.md b/ej2-react/diagram/layout-customization.md
index 84570ba99..d201c097f 100644
--- a/ej2-react/diagram/layout-customization.md
+++ b/ej2-react/diagram/layout-customization.md
@@ -1,26 +1,26 @@
---
layout: post
-title: Customizing layout in React Diagram component | Syncfusion®
-description: Learn here all about Customizing layout in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Customizing layout in React Diagram Component | Syncfusion®
+description: Learn here all about Customizing layout in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Customizing layout
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Customizing layout in React Diagram control
+# Customizing layout in React Diagram Component
-Orientation, spacings, and alignment of the layout can be customized with a set of properties.
+The React Diagram component provides extensive customization options for automatic layouts, allowing developers to control orientation, spacing, alignment, bounds, and visual behavior. These properties enable fine-tuned positioning and appearance of nodes within hierarchical, organizational, and tree-based diagrams.
-To explore layout properties, refer to [`Layout Properties`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#properties).
+To explore all available layout properties, refer to[`Layout Properties`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#properties).
-## Layout bounds
+## Layout Bounds
+The diagram supports aligning layouts within custom rectangular areas using layout bounds. This feature constrains the layout to a specific region of the canvas, providing precise control over where the layout appears.
-Diagram provides support to align the layout within any custom rectangular area.
-
-The following example shows how to align the layout within the given layout bounds.
+Layout bounds define a rectangular area where the entire layout will be positioned. This is particularly useful when integrating diagrams into dashboards or when multiple layouts need to coexist on the same canvas.
+The following example shows how to align the layout within specified layout bounds:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -38,12 +38,13 @@ The following example shows how to align the layout within the given layout boun
For more information about bounds, refer to [`bounds`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#bounds).
-## Layout alignment
+## Layout Alignment
-The layout can be aligned anywhere over the layout bounds/viewport using the [`horizontalAlignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#horizontalalignment) and [`verticalAlignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#verticalalignment) properties of the layout.
+The layout can be positioned anywhere within the layout bounds using [`horizontalAlignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#horizontalalignment) and [`verticalAlignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#verticalalignment) properties. These properties determine how the layout is positioned relative to its container.
-The following code illustrates how to align the layout and how to change layout horizontal and vertical alignment at runtime.
+Available alignment options include Left, Right, Center for horizontal alignment, and Top, Bottom, Center for vertical alignment. These settings work independently, allowing for precise positioning control.
+The following code illustrates how to configure layout alignment and modify alignment properties at runtime:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -58,12 +59,13 @@ The following code illustrates how to align the layout and how to change layout
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/layout-alignment-cs1" %}
-## Layout spacing
+## Layout Spacing
-Layout provides support to add space horizontally and vertically between the nodes. The [`horizontalSpacing`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#horizontalspacing) and [`verticalSpacing`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#verticalspacing) properties of the layout allows you to set the space between the nodes in horizontally and vertically.
+Layout spacing controls the distance between nodes in the layout. The[`horizontalSpacing`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#horizontalspacing) and [`verticalSpacing`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#verticalspacing) properties define the gaps between nodes horizontally and vertically respectively.
-The following code illustrates how to set the initial horizontal and vertical spacing for the layout, as well as how to change these spacing values at runtime
+Proper spacing ensures visual clarity and prevents node overlap. Spacing values are measured in pixels and can be adjusted based on node sizes and content density requirements.
+The following code illustrates how to set initial horizontal and vertical spacing for the layout and modify these values at runtime:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -77,13 +79,13 @@ The following code illustrates how to set the initial horizontal and vertical sp
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/layout-spacing-cs1" %}
+## Layout Margin
-## Layout margin
-
-Layout provides support to add some blank space between the layout bounds/viewport and the layout. The [`margin`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#margin) property of the layout allows you to set the blank space.
+Layout margin creates blank space between the layout bounds and the actual layout content. The [`margin`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#margin) property adds padding around the entire layout, ensuring adequate separation from container edges.
-The following code demonstrates how to set the initial layout margin and how to modify the layout margin dynamically at runtime.
+Margins are particularly useful when layouts are displayed within panels, cards, or other UI containers where visual separation is important for clarity and aesthetics.
+The following code demonstrates how to set initial layout margin and modify margin values dynamically at runtime:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -98,20 +100,20 @@ The following code demonstrates how to set the initial layout margin and how to
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/layout-margin-cs1" %}
-## Layout orientation
+## Layout Orientation
-The layout orientation can used to arrange the layout based on the direction. there are different orientation types that are defined in the following table.
+The layout orientation determines the primary direction in which the layout flows. Different orientations are suitable for various organizational structures and display requirements.
|Orientation|Description|
| -------- | ----------- |
-|TopToBottom|Aligns the layout from top to bottom. All the roots are placed at top of diagram.|
-|LeftToRight|Aligns the layout from left to right. All the roots are placed at left of diagram.|
-|BottomToTop|Aligns the layout from bottom to top. All the roots are placed at bottom of the diagram.|
-|RightToLeft|Aligns the layout from right to left. All the roots are placed at right of the diagram.|
+|TopToBottom|Aligns the layout from top to bottom. All root nodes are placed at the top of the diagram.|
+|LeftToRight|Aligns the layout from left to right. All root nodes are placed at the left of the diagram.|
+|BottomToTop|Aligns the layout from bottom to top. All root nodes are placed at the bottom of the diagram.|
+|RightToLeft|Aligns the layout from right to left. All root nodes are placed at the right of the diagram.|
-Diagram provides support to customize the [`orientation`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#orientation) of layout. You can set the desired orientation using layout.orientation.
+Diagram provides support to customize the [`orientation`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#orientation) property can be customized to match specific design requirements or cultural reading patterns.
->Note: In the diagram the default orientation is `TopToBottom`.
+>Note: In the diagram the default orientation is **TopToBottom**.
The following code demonstrates how to set the initial orientation for the layout and how to change it dynamically at runtime.
@@ -129,12 +131,13 @@ The following code demonstrates how to set the initial orientation for the layou
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/layout-orientation-cs1" %}
-## Exclude from layout
+## Exclude From Layout
-In some cases, you may need one or two nodes not to be arranged based on the layout algorithm but instead positioned manually. You can exclude these nodes from the layout algorithm by setting the [`excludeFromLayout`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeModel/#excludefromlayout) property to true.
+In certain scenarios, specific nodes may need manual positioning rather than automatic arrangement by the layout algorithm. These nodes can be excluded from layout calculations by setting the[`excludeFromLayout`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeModel/#excludefromlayout) property to **true**.
-The following code example demonstrates how to exclude a node from the layout and position it manually:
+This feature is useful for annotation nodes, floating panels, or special elements that require fixed positioning regardless of the overall layout structure.
+The following code example demonstrates how to exclude a node from the layout and position it manually:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -148,11 +151,11 @@ The following code example demonstrates how to exclude a node from the layout an
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/layout-exclude-cs1" %}
+## Fixed Node
-## Fixed node
-
-Layout provides support to arrange the nodes with reference to the position of a fixed node and set it to the [`fixedNode`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#fixednode) of the layout property. This is helpful when you try to expand/collapse a node. It might be expected that the position of the double-clicked node should not be changed.
+Layout provides support to arrange the nodes with reference to the position of a fixed node and set it to the [`fixedNode`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#fixednode) property. This ensures that the specified node maintains its position while other nodes are arranged around it.
+This feature is particularly beneficial during expand/collapse operations, where maintaining the position of the interacted node provides better user experience and visual stability.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -166,11 +169,13 @@ Layout provides support to arrange the nodes with reference to the position of a
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/layout-fixed-cs1" %}
+## Expand and Collapse
-## Expand and collapse
+The diagram supports expanding and collapsing subtrees within layouts. The node's isExpanded property controls the visibility of child nodes, allowing users to focus on specific portions of large hierarchical structures.
-Diagram allows to expand/collapse the subtrees of a layout. The node’s isExpanded property allows you to expand/collapse its children. The following code example shows how to expand/collapse the children of a node.
+This functionality is essential for managing complex organizational charts, decision trees, and other hierarchical data where progressive disclosure improves usability.
+The following code example shows how to expand/collapse the children of a node:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -185,14 +190,15 @@ Diagram allows to expand/collapse the subtrees of a layout. The node’s isExpan
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/layout-expandandcollapse-cs1" %}
-For more details about customizing the expand and collapse icon refer [`expand Collapse`](./nodes-expandAndCollapse)
+For more details about customizing the expand and collapse icon refer [`expand Collapse`](./nodes-expandAndCollapse).
-## Layout animation
+## Layout Animation
-While performing expand and collapse operations, the layout can be animated by applying a small delay. This can be achieved by setting the [`enableAnimation`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#enableanimation) property of the layout. By default, `enableAnimation` is set to true.
+Expand and collapse operations can be animated by applying transitions during layout changes. The[`enableAnimation`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#enableanimation) property controls this behavior, enhancing the visual experience during structural changes.
-In the following example, the enableAnimation property ensures that the layout changes are animated, enhancing the visual experience during expand and collapse operations.
+Animation provides visual continuity and helps users track changes in the layout structure. By default, `enableAnimation` is set to **true**.
+The following example demonstrates how layout animation enhances the visual experience during expand and collapse operations:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -207,14 +213,15 @@ In the following example, the enableAnimation property ensures that the layout c
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/layout-animation-cs1" %}
->Note: To enable layout animation, you need to inject LayoutAnimation module in diagram.
+>Note: To enable layout animation, inject the LayoutAnimation module in the diagram.
-## Parent - child relation with dropped nodes from symbol palette
+## Parent - Child Relation with Dropped Nodes from Symbol Palette
-You can create a layout with dropped nodes from symbol palette using the [`drop`](https://ej2.syncfusion.com/react/documentation/api/diagram/#drop) event. In `drop` event, you have to create a connection between the source and target item.
+Layouts can be dynamically extended by creating parent-child relationships between existing nodes and items dropped from the symbol palette. The [`drop`](https://ej2.syncfusion.com/react/documentation/api/diagram/#drop) event provides the mechanism to establish these connections programmatically.
-Find the code example to create parent - child relation between source and target nodes in drop event.
+This functionality enables interactive diagram building, where users can expand existing structures by dragging and dropping new elements from a predefined set of symbols.
+The following code example creates parent-child relationships between source and target nodes in the drop event:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -254,14 +261,14 @@ The [`orientation`](https://ej2.syncfusion.com/react/documentation/api/diagram/s
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/layout-setNodeTemplete-cs1" %}
-## Refresh layout
+## Refresh Layout
+
+The diagram supports refreshing layouts at runtime to reflect structural or data changes. The [`doLayout`](https://ej2.syncfusion.com/react/documentation/api/diagram/#dolayout) method recalculates and redraws the entire layout based on current data and configuration.
-Diagram allows refreshing the layout at runtime. To refresh the layout, you need to call the [`doLayout`](https://ej2.syncfusion.com/react/documentation/api/diagram/#dolayout) method.
+This functionality is essential when nodes are added, removed, or modified programmatically, ensuring the layout remains consistent with the updated structure.
```typescript
//To refresh layout
diagramInstance.doLayout();
-
-```
-
+```
\ No newline at end of file
diff --git a/ej2-react/diagram/layout-event.md b/ej2-react/diagram/layout-event.md
index 5b4833b75..6f1cd1986 100644
--- a/ej2-react/diagram/layout-event.md
+++ b/ej2-react/diagram/layout-event.md
@@ -1,18 +1,23 @@
---
layout: post
-title: Layout events in React Diagram component | Syncfusion®
-description: Learn here all about Layout events in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Layout events in React Diagram Component | Syncfusion®
+description: Learn here all about Layout events in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Layout events
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Layout events in React Diagram control
+# Layout events in React Diagram Component
+Layout events in the React Diagram component provide developers with hooks to respond to various stages of automatic layout processing. These events are particularly useful when working with hierarchical data structures and need to customize behavior during layout rendering, data loading, or node expansion/collapse operations.
-## DataLoaded event
+The diagram component supports several layout-specific events that fire during different phases of the layout life cycle, enabling fine-grained control over layout behavior and user interactions.
-The [`dataLoaded`](https://ej2.syncfusion.com/react/documentation/api/diagram/idataloadedeventargs/) event is triggered after the diagram is populated from the external data source.
+## DataLoaded Event
+
+The [`dataLoaded`](https://ej2.syncfusion.com/react/documentation/api/diagram/idataloadedeventargs/) event triggers after the diagram successfully populates from an external data source. This event provides access to the loaded data and diagram instance, making it ideal for performing post-load customizations such as applying custom styling, setting initial node states, or configuring layout-specific properties.
+
+The event fires once the data binding process completes but before the initial layout calculation begins, providing an opportunity to modify nodes or connectors before they are positioned.
The following code example explains the data loaded event in the diagram.
@@ -35,12 +40,11 @@ The following code example explains the data loaded event in the diagram.
```
-## ExpandStateChange event
+## ExpandStateChange Event
-The [`expandStateChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExpandStateChangeEventArgs/) will be triggered when the state of the expand and collapse icon change for a node.
-
-The following code example explains the `expandStateChange` event in the diagram.
+The [`expandStateChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/iExpandStateChangeEventArgs/) event fires when a user clicks the expand or collapse icon of a node in a hierarchical layout. This event occurs before the layout update begins, allowing developers to prevent the state change, modify the expansion behavior, or trigger custom actions based on the node's new state.
+The event provides information about the affected node, its current state, and whether the operation can be canceled. This makes it valuable for implementing conditional expansion, loading child data on-demand, or applying custom animations.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -55,10 +59,11 @@ The following code example explains the `expandStateChange` event in the diagram
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/layoutEvent-cs1" %}
-## Animation complete event
+## Animation Complete Event
-The [`animationComplete`](https://ej2.syncfusion.com/react/documentation/api/diagram/#animationcomplete) event is triggered after the animation of the diagram elements is completed. The following example demonstrates how to handle the animation complete event and customize based on the expand state of the root node.
+The [`animationComplete`](https://ej2.syncfusion.com/react/documentation/api/diagram/#animationcomplete) event triggers after the diagram finishes animating layout changes, particularly during expand and collapse operations. This event is essential for detecting when visual transitions have completed, enabling developers to perform follow-up actions such as scrolling to specific nodes, updating UI indicators, or triggering additional layout adjustments.
+The event fires at the end of the animation cycle, ensuring that all visual updates are complete before any subsequent operations begin.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -72,11 +77,11 @@ The [`animationComplete`](https://ej2.syncfusion.com/react/documentation/api/dia
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/layoutEvent-cs2" %}
-## Layout updated event
+## Layout Updated Event
-The [`layoutUpdated`](https://ej2.syncfusion.com/react/documentation/api/diagram/#layoutupdated) event is triggered when the layout rendering process in the diagram either starts or completes. This event allows users to track the state of the layout rendering process.
+The [`layoutUpdated`](https://ej2.syncfusion.com/react/documentation/api/diagram/#layoutupdated) event fires at both the beginning and completion of the layout rendering process. This event enables tracking of layout calculation progress and provides timing information for performance monitoring or progress indication purposes.
-The following code example explains the layout updated event in the diagram.
+The event includes a state parameter that indicates whether the layout process is starting or finishing, allowing developers to implement loading indicators, measure layout performance, or coordinate with other application components that depend on layout completion.
```javascript
function handleLayoutUpdated(args){
@@ -93,4 +98,5 @@ function handleLayoutUpdated(args){
{/* Inject necessary services for the diagram */}
-```
\ No newline at end of file
+```
+These layout events work together to provide comprehensive control over the automatic layout life cycle, from initial data loading through final rendering completion. They enable developers to create responsive, interactive diagram experiences with proper feedback and customization capabilities.
\ No newline at end of file
diff --git a/ej2-react/diagram/localization.md b/ej2-react/diagram/localization.md
index 32ce18375..68b38c2b4 100644
--- a/ej2-react/diagram/localization.md
+++ b/ej2-react/diagram/localization.md
@@ -1,18 +1,18 @@
---
layout: post
-title: Localization in React Diagram component | Syncfusion®
-description: Learn here all about Layers in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Localization in React Diagram Component | Syncfusion®
+description: Learn how to localize context menus and symbol palette functionality in Syncfusion® React Diagram Component with culture-specific text.
control: Localization
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Localization in EJ2 React Diagram control
+# Localization in EJ2 React Diagram Component
-The EJ2 Diagram component supports `localization`. In the Diagram component, the symbol palette search box and context menu items can be localized based on the selected culture. By using the locale property of the diagram, you can change the culture.
+The EJ2 React Diagram component supports localization functionality, allowing developers to adapt the user interface to different languages and regions. The diagram's symbol palette search box and context menu items can be localized based on the selected culture. Use the locale property of the diagram to specify the desired culture for localization.
-## Localize Diagram context menu
+## Localize Diagram Context Menu
To localize the diagram context menu, we need to define the [`locale`](https://ej2.syncfusion.com/react/documentation/api/diagram/#locale) property of the diagram with our preferred culture. In the example below, we use **'de-DE**', which is the locale code for German as used in Germany.
@@ -27,9 +27,9 @@ To localize the diagram context menu, we need to define the [`locale`](https://e
nodes={node}/>
```
-Next, we need to call the `setCulture('de')` function, which sets the default culture for all EJ2 components. This method takes one parameter, cultureName, which specifies the culture name to be set as the default.
+Next, call the `setCulture('de')` function to set the default culture for all EJ2 components. This method accepts one parameter, cultureName, which specifies the culture name to be set as the default.
-We also need to define the text we want to render in the context menu instead of the default English, as shown below.
+Define the localized text for the context menu items to replace the default English text:
```javascript
@@ -60,7 +60,7 @@ L10n.load({
```
-The following code example summarizes the locale settings for the context menu.
+The following code example demonstrates the complete locale settings for the context menu:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -73,13 +73,13 @@ The following code example summarizes the locale settings for the context menu.
{% previewsample "page.domainurl/code-snippet/diagram/localization/es5localeContextMenu-cs1" %}
-## Localize Symbol palette
+## Localize Symbol Palette
-You can enable the search option in the symbol palette to search for symbols by using the [`enableSearch`](../api/diagram/symbolPaletteModel/#enablesearch) option. This search box can also be localized.
+Enable the search functionality in the symbol palette using the [`enableSearch`](../api/diagram/symbolPaletteModel/#enablesearch) property. The search box supports localization to match the application's target language.
-To localize the symbol palette search box, we need to define the [`locale`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPaletteModel/#locale) property of the symbol palette with our preferred culture. In the example below, we use **'de-DE**', which is the locale code for German as used in Germany.
+To localize the symbol palette search box, define the [`locale`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPaletteModel/#locale) property of the symbol palette with the preferred culture. The example below uses 'de-DE' for German localization.
-The following code shows how to localize symbol palette.
+The following code demonstrates symbol palette localization:
```javascript
// Set the default culture to German
diff --git a/ej2-react/diagram/mindmap-layout.md b/ej2-react/diagram/mindmap-layout.md
index 0d78fb167..04844a85d 100644
--- a/ej2-react/diagram/mindmap-layout.md
+++ b/ej2-react/diagram/mindmap-layout.md
@@ -1,24 +1,23 @@
---
layout: post
-title: Mind-map layout in React Diagram component | Syncfusion®
-description: Learn here all about Mind-map layout in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Mind-map layout in React Diagram Component | Syncfusion®
+description: Learn here all about Mind-map layout in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Mind-map layout
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Mind Map layout in React Diagram control
+# Mind Map layout in React Diagram Component
-A mind map is a diagram that displays the nodes as a spider diagram organizes information around a central concept. To create mind map, the [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#type) of layout should be set as `MindMap`.
+A mind map is a powerful visualization technique that organizes information around a central concept, with related topics branching outward in a tree-like structure. This layout is particularly useful for brainstorming, knowledge mapping, and hierarchical data representation. The React Diagram component supports mind map layouts through the [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#type) property, which should be set to **MindMap**.
## Mind Map Orientation
-An [`Orientation`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#orientation) of a `MindMapTreeLayout` is used to arrange the tree layout according to a specific direction. By default, the orientation is set to Horizontal.
-
-The following code example illustrates how to create an mindmap layout.
+An [`Orientation`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#orientation) property determines how the mind map tree structure is arranged spatially. By default, the orientation is set to **Horizontal**, positioning the root node centrally with branches extending left and right.
+The following code example demonstrates how to create a mind map layout:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -37,15 +36,17 @@ The following table outlines the various orientation types available:
|Orientation Type |Description|
| -------- | ----------- |
-|Horizontal|Aligns the tree layout from left to right|
-|Vertical|Aligns the tree layout from top to bottom|
+|Horizontal|Arranges the mind map with the root node centered, branches extending horizontally left and right|
+|Vertical|Arranges the mind map with the root node at the top or center, branches extending vertically up and down|
>Note: If you want to use mind map layout in diagram, you need to inject MindMap in the diagram.
-## Mind Map branch
+## Mind Map Branch
+
+The mind map layout provides flexible branch positioning through the [`getBranch`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#getbranch) method. This method allows you to control which side of the root node each branch appears on, enabling customized layouts based on your specific requirements.
-You can also decide the branch for mind map using [`getBranch`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#getbranch) method. The following code demonstrates how to set all branches on the right side for mind map layout using `getBranch` method.
+The `getBranch` method receives a node object as a parameter and should return a string value indicating the desired branch position: **Left**, **Right**, or **SubLeft**/'**SubRight** for nested branches. The following code example shows how to position all branches on the right side of the mind map:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -59,4 +60,21 @@ You can also decide the branch for mind map using [`getBranch`](https://ej2.sync
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/mindMap-cs2" %}
-
\ No newline at end of file
+
+
+## Common Use Cases
+
+Mind map layouts are ideal for:
+- **Brainstorming sessions**: Visualizing ideas and their relationships.
+- **Knowledge mapping**: Organizing complex information hierarchically.
+- **Decision trees**: Mapping out decision processes and outcomes.
+- **Organizational charts**: Displaying reporting structures with a central focus.
+- **Project planning**: Breaking down projects into manageable components.
+
+## Best Practices
+
+- Keep the root node content concise and descriptive.
+- Use consistent styling for nodes at the same hierarchical level.
+- Limit branch depth to maintain readability.
+- Consider color coding to differentiate branch categories.
+- Ensure adequate spacing between branches to prevent overlap.
\ No newline at end of file
diff --git a/ej2-react/diagram/multipleSegments.md b/ej2-react/diagram/multipleSegments.md
index 153b1ebad..bdb955707 100644
--- a/ej2-react/diagram/multipleSegments.md
+++ b/ej2-react/diagram/multipleSegments.md
@@ -1,16 +1,21 @@
---
layout: post
-title: Multiple segments in React Diagram component | Syncfusion®
-description: Learn here how to create connectors with multiple segments in in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Multiple Segments for Connector in React Diagram Component | Syncfusion®
+description: Learn how to create connectors with multiple segments in Syncfusion® React Diagram Component, including configuration and practical examples.
control: Multiple segments
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
+# Multiple Segments for Connectors
+Connectors in the React Diagram component can be composed of multiple segments to create complex routing paths between nodes. Multiple segments allow you to define precise connection routes that navigate around obstacles or follow specific pathways in your diagram layout.
-# Create multiple segments
+## Understanding Connector Segments
+A connector segment represents a portion of the connector's path. By combining multiple segments, you can create connectors that change direction multiple times, forming L-shapes, Z-shapes, or more complex routing patterns. Each segment can have different properties and behaviors depending on the segment type used.
-Multiple segments can be defined one after another. To create a connector with multiple segments, define and add the segments to the [`segments`] collection. The following code example illustrates how to create a connector with multiple segments.
+## Create Multiple Segments
+Multiple segments can be defined sequentially to form a complete connector path. To create a connector with multiple segments, define and add the segments to the [`segments`](https://ej2.syncfusion.com/react/documentation/api/diagram/connector/#segments) collection.
+The following example demonstrates how to create a connector with multiple segments that forms a custom routing path:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/node-labels.md b/ej2-react/diagram/node-labels.md
index 86d216781..d5d30f744 100644
--- a/ej2-react/diagram/node-labels.md
+++ b/ej2-react/diagram/node-labels.md
@@ -8,22 +8,28 @@ documentation: ug
domainurl: ##DomainURL##
---
-# Node annotations in React Diagram component
+# Node Annotations in React Diagram Component
-Diagram allows you to customize the position and appearance of the annotation efficiently. Annotation can be aligned relative to the node boundaries. It has Margin, Offset, Horizontal, and Vertical alignment properties. It is quite tricky when all four alignments are used together but gives more control over alignments properties of the ShapeAnnotation class. Annotations of a node can be positioned using the following properties of ShapeAnnotation.
+The React Diagram component allows precise customization of node annotations (also called labels) for positioning and appearance. Node annotations can be aligned relative to node boundaries using four key positioning properties that work together to provide comprehensive control over annotation placement.
-* Offset
-* HorizontalAlignment
-* VerticalAlignment
-* Margin
+## Annotation positioning properties
+
+Node annotations support the following positioning properties through the ShapeAnnotation class:
+
+* **Offset** - Controls fractional positioning within the node bounds.
+* **HorizontalAlignment** - Sets horizontal alignment at the calculated position.
+* **VerticalAlignment** - Sets vertical alignment at the calculated position.
+* **Margin** - Adds spacing around the annotation.
+
+These properties can be combined to achieve precise annotation positioning for various design requirements.
## Set annotation offset and size
-The [`offset`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointModel/) property of an annotation is used to align annotations based on fractional values. The offset can be customized by modifying the x and y values of the offset property. By default, the annotation offset is set to 0.5 on both the x and y axes.
+The [`offset`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointModel/) property positions annotations using fractional values between 0 and 1. The offset represents the relative position within the node boundaries, where (0,0) is the top-left corner and (1,1) is the bottom-right corner. The default offset is (0.5, 0.5), which centers the annotation.
-By default, the size of the annotation is calculated based on its content. If you want to set the size externally, you can do so using the [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#height) properties of annotation.
+The annotation size is automatically calculated based on its content. To specify custom dimensions, use the [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#height) properties.
-The following code shows how to set offset, height and width for the annotation.
+The following example demonstrates how to configure offset, width, and height for node annotations:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -38,7 +44,7 @@ The following code shows how to set offset, height and width for the annotation.
### Update annotation offset at runtime
-The annotation offset can be updated dynamically at runtime. To update the annotation offset, fetch the annotation you want to update and modify its offset.
+Annotation offset values can be modified dynamically during application execution. To update the offset, access the target annotation and modify its offset properties, then call the `dataBind()` method to apply changes immediately.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -51,9 +57,11 @@ The annotation offset can be updated dynamically at runtime. To update the annot
{% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Update-cs4" %}
-N> Call `dataBind()` after property change to reflect the changes instantly.
+N> Call `dataBind()` after property changes to reflect updates instantly.
-The following table shows the position of annotation with different offsets.
+### Annotation offset positions
+
+The following table demonstrates annotation positioning with different offset values:
offset|image|
|-----|-----|
@@ -69,9 +77,11 @@ offset|image|
## Annotation alignment
-The [`horizontalAlignment`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#horizontalalignment) property of annotation is used to set how the annotation is horizontally aligned at the annotation position determined from the fraction values. The [`verticalAlignment`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#verticalalignment) property is used to set how annotation is vertically aligned at the annotation position.
+After determining the annotation position using offset values, the [`horizontalAlignment`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#horizontalalignment) property of annotation is used to set how the annotation is horizontally aligned at the annotation position determined from the fraction values. The [`verticalAlignment`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationModel/#verticalalignment) properties control how the annotation aligns at that calculated position.
+
+The horizontal alignment determines the annotation's horizontal positioning relative to the calculated point, while vertical alignment controls the vertical positioning. This two-step positioning system (offset calculation followed by alignment) provides precise control over annotation placement.
-The following codes illustrates how to align annotations.
+The following example shows how to configure annotation alignment properties:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -84,7 +94,9 @@ The following codes illustrates how to align annotations.
{% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Alignment-cs1" %}
-The following tables illustrates all the possible alignments visually with 'offset (0, 0)'.
+### Alignment combinations
+
+The following table shows all possible alignment combinations with offset (0,0) to demonstrate the alignment behavior:
| Horizontal Alignment | Vertical Alignment | Output with Offset(0,0) |
| -------- | -------- | -------- |
@@ -100,7 +112,7 @@ The following tables illustrates all the possible alignments visually with 'offs
### Update annotation alignment at runtime
-Annotation alignment can be updated dynamically at runtime. The following code example shows how to update annotation alignment at runtime.
+Annotation alignment properties can be modified dynamically during application execution. The following example demonstrates updating alignment properties at runtime:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -111,7 +123,4 @@ Annotation alignment can be updated dynamically at runtime. The following code e
{% endhighlight %}
{% endtabs %}
- {% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Alignment-cs2" %}
-
-
-
+ {% previewsample "page.domainurl/code-snippet/diagram/annotations/es5Alignment-cs2" %}
\ No newline at end of file
diff --git a/ej2-react/diagram/nodes-customization.md b/ej2-react/diagram/nodes-customization.md
index 6f7ad0d54..4954be142 100644
--- a/ej2-react/diagram/nodes-customization.md
+++ b/ej2-react/diagram/nodes-customization.md
@@ -8,17 +8,16 @@ documentation: ug
domainurl: ##DomainURL##
---
-# Appearence of a nodes in React Diagram control
+# Appearance of Nodes in React Diagram Component
To customize the appearance and position of nodes in the React Diagram component, refer to the video link below.
{% youtube "https://www.youtube.com/watch?v=pn02S_rwupw" %}
## Common values to the node.
+The [`getNodeDefaults`](https://ej2.syncfusion.com/react/documentation/api/diagram/#getnodedefaults) property in the React Diagram control allows you to define default settings that apply to all nodes based on specific conditions or requirements. This approach ensures consistency across your diagram and reduces repetitive code.
-The [`getNodeDefaults`](https://ej2.syncfusion.com/react/documentation/api/diagram/#getnodedefaults) property in the EJ2 Diagram control allows you to define default settings for nodes based on specific conditions or requirements.
-
-The following code example shows how to use getNodeDefaults function.
+The following code example shows how to use the getNodeDefaults function to apply common styling to all nodes:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -35,11 +34,11 @@ N> The value we set in the getNodeDefaults has the higher priority in rendering.
## Appearance
-### Apply style to the node
-
+### Apply style to nodes
+
The appearance of a node can be customized by changing its [`fill`](https://ej2.syncfusion.com/react/documentation/api/diagram/shapeStyleModel/#fill) color, [`strokeDashArray`](https://ej2.syncfusion.com/react/documentation/api/diagram/shapeStyleModel/#strokedasharray), ['strokeWidth'](https://ej2.syncfusion.com/react/documentation/api/diagram/shapeStyleModel/#strokewidth), ['strokeColor'](https://ej2.syncfusion.com/react/documentation/api/diagram/shapeStyleModel/#strokecolor) and [`opacity`](https://ej2.syncfusion.com/react/documentation/api/diagram/shapeStyleModel/#opacity). The [`visible`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#visible) property of the node enables or disables the visibility of the node.
-The following code illustrates how to customize the appearance of the shape.
+The following code illustrates how to customize the appearance of nodes using style properties:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -52,26 +51,23 @@ The following code illustrates how to customize the appearance of the shape.
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nCustomization-cs2" %}
-## Gradient
-
-The [`gradient`](https://ej2.syncfusion.com/react/documentation/api/diagram/gradientModel/) property of the node allows you to define and apply the gradient effect to that node.
-
-The gradient stop property defines the color and a position, where the previous color transition ends and a new color transition starts.
-
-The gradient stop’s opacity property defines the transparency level of the region.
-
-There are two types of gradients as follows:
+### Apply gradient style to nodes
+The [`gradient`](https://ej2.syncfusion.com/react/documentation/api/diagram/gradientModel/) property of the node allows you to define and apply gradient effects to create visually appealing nodes with smooth color transitions.
+
+The gradient stop property defines the color and position where the previous color transition ends and a new color transition starts. The gradient stop's opacity property defines the transparency level of the region.
+
+There are two types of gradients available:
+
* Linear gradient
-
* Radial gradient
+
+#### Linear gradient
-## Linear gradient
-
-* [`LinearGradient`](https://ej2.syncfusion.com/react/documentation/api/diagram/lineargradientmodel/) defines a smooth transition between a set of colors (so-called stops) on a line.
-
-* A linear gradient’s x1, y1, x2, y2 properties are used to define the position (relative to the node) of the rectangular region that needs to be painted.
-
+* [`LinearGradient`](https://ej2.syncfusion.com/react/documentation/api/diagram/lineargradientmodel/) defines a smooth transition between a set of colors (called stops) along a straight line. This is ideal for creating directional color effects on nodes.
+
+A linear gradient's x1, y1, x2, y2 properties are used to define the position (relative to the node) of the rectangular region that needs to be painted.
+
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
{% include code-snippet/diagram/nodes/nCustomization-cs3/app/index.jsx %}
@@ -83,12 +79,12 @@ There are two types of gradients as follows:
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nCustomization-cs3" %}
-## Radial gradient
-
-* [`RadialGradient`](https://ej2.syncfusion.com/react/documentation/api/diagram/radialGradientModel/) defines a smooth transition between stops on a circle.
-
-* A radial gradient’s cx, cy, fx, fy properties are used to define the position (relative to the node) of the outermost or the innermost circle of the radial gradient.
-
+#### Radial gradient
+
+* [`RadialGradient`](https://ej2.syncfusion.com/react/documentation/api/diagram/radialGradientModel/) defines a smooth transition between stops that radiates from a central point in a circular pattern. This creates a spotlight or glow effect on nodes.
+
+A radial gradient's cx, cy, fx, fy properties are used to define the position (relative to the node) of the outermost or innermost circle of the radial gradient.
+
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
{% include code-snippet/diagram/nodes/nCustomization-cs4/app/index.jsx %}
@@ -104,11 +100,9 @@ There are two types of gradients as follows:
### Customize the style of main node selector indicator
-In diagram, multiple nodes can be selected.
-While selecting multiple nodes, a highlighter will be rendered to indicate the selection of each nodes.
-The border style of the first node in the multiple selection can be customized by using the className [`e-diagram-first-selection-indicator`].
+In the diagram, multiple nodes can be selected simultaneously. When selecting multiple nodes, a highlighter renders to indicate the selection of each node. The border style of the first node in the multiple selection can be customized using the CSS class name [`e-diagram-first-selection-indicator`].
-Use the following CSS to customize the style of main node on multiple selection.
+Use the following CSS to customize the style of the main node during multiple selection:
```css
@@ -120,15 +114,15 @@ Use the following CSS to customize the style of main node on multiple selection.
```
-## Apply rotate angle and corner radius to the node
+## Apply rotate angle and corner radius to nodes
-- `Rotate angle`: The [`rotateAngle`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#rotateangle) property allows you to rotate nodes within the diagram. It's particularly useful when you want to represent nodes from different perspectives or angles.
+Node appearance can be enhanced using rotation and corner radius properties:
-- `Corner radius`: The [`cornerRadius`](https://ej2.syncfusion.com/react/documentation/api/diagram/basicShapeModel/#cornerradius) property allows you to round the corners of nodes in the diagram.
-It adds a visual styling effect to the nodes, making them appear softer or more polished.
+- **Rotate angle**: The [`rotateAngle`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#rotateangle)property allows you to rotate nodes within the diagram. This is particularly useful when you want to represent nodes from different perspectives or angles to match your design requirements.
+- **Corner radius**: The [`cornerRadius`](https://ej2.syncfusion.com/react/documentation/api/diagram/basicShapeModel/#cornerradius) property allows you to round the corners of rectangular nodes in the diagram. It adds a visual styling effect to the nodes, making them appear softer and more polished.
-The following code shows how to set the rotate angle and corner radius for the node.
+The following code shows how to set the rotate angle and corner radius for nodes:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -141,10 +135,11 @@ The following code shows how to set the rotate angle and corner radius for the n
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nCustomization-cs5" %}
-## Apply shadow effect to node
+## Apply shadow effect to nodes
-Diagram provides support to add [`shadow`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#shadow) effect to a node that is disabled, by default. It can be enabled with the
-constraints property of the node. The following code illustrates how to drop shadow.
+Diagram provides support to add [`shadow`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#shadow) effects to nodes, which is disabled by default. Shadow effects can be enabled using the constraints property of the node to create depth and visual hierarchy in your diagrams.
+
+The following code illustrates how to apply shadow effects to nodes:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -157,9 +152,11 @@ constraints property of the node. The following code illustrates how to drop sha
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nCustomization-cs6" %}
-### Customizing shadow effect of the node
+### Customizing shadow effects
-The angle, distance, and opacity of the shadow can be customized with the shadow property of the node. The following code example illustrates how to customize shadow.
+The [`angle`](https://ej2.syncfusion.com/react/documentation/api/diagram/shadowModel/#angle), [`distance`](https://ej2.syncfusion.com/react/documentation/api/diagram/shadowModel/#distance), and [`opacity`](https://ej2.syncfusion.com/react/documentation/api/diagram/shadowModel/#opacity) of the shadow can be customized using the `shadow` property of the node. These properties allow you to control the direction, positioning, and transparency of the shadow effect.
+
+The following code example illustrates how to customize shadow properties:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -174,9 +171,9 @@ The angle, distance, and opacity of the shadow can be customized with the shadow
## Provide additional information to the node
-The [`addInfo`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#addinfo) property of the node allows you to maintain additional information to the node. You can specify either object or string value.
+The [`addInfo`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#addinfo) property of the node allows you to maintain additional information with the node. You can specify either object or string values to store custom data that can be retrieved and used in your application logic.
-The following code shows how to set the AddInfo value.
+The following code shows how to set the addInfo value:
```ts
import * as React from "react";
@@ -217,11 +214,11 @@ root.render();
## Constraints
-The [`constraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#constraints) property of the node allows you to enable/disable certain behaviors of the node. For more information about node constraints refer to the [`Node Constraints`](./constraints#node-constraints)
+The [`constraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#constraints) property of the node allows you to enable or disable certain behaviors of the node. This provides fine-grained control over node interactions and capabilities. For more information about node constraints, refer to the [`Node Constraints`](./constraints#node-constraints) documentation.
## Stack order
-The nodes [`zIndex`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#zindex) property specifies the stack order of the node. A node with greater stack order is always in front of a node with a lower stack order.
+The [`zIndex`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#zindex) property of nodes specifies the stack order of the node. A node with a greater stack order is always rendered in front of a node with a lower stack order, allowing you to control the layering of overlapping elements.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -238,9 +235,9 @@ N> By default, the zIndex will be generated automatically based on the order of
## Pivot
-Node rotation angle will be based on [`Pivot`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#pivot) values which range from 0 to 1 like offset values. By default, the Pivot values are set to X= 0.5 and Y=0.5.
+Node rotation angle will be based on [`Pivot`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#pivot) values which range from 0 to 1, similar to offset values. By default, the pivot values are set to X = 0.5 and Y = 0.5, meaning rotation occurs around the center of the node.
-The following table illustrates how pivot relates offset values with node boundaries.
+The following table illustrates how pivot relates to offset values with node boundaries:
| Pivot | Offset |
|-------- | -------- |
@@ -263,7 +260,7 @@ The following code illustrates how to change the `pivot` value.
## Get connected connector from node
-Node has the InEdges and OutEdges read-only property. In this property, you can find what are all the connectors that are connected to the node, and then you can fetch these connectors by using the [`getObject`](https://ej2.syncfusion.com/react/documentation/api/diagram/#getobject) method in the diagram.
+Node has the inEdges and outEdges read-only properties. These properties allow you to identify all connectors that are connected to the node. You can then retrieve these connectors using the [`getObject`](https://ej2.syncfusion.com/react/documentation/api/diagram/#getobject) method in the diagram.
```ts
import * as React from "react";
diff --git a/ej2-react/diagram/nodes-events.md b/ej2-react/diagram/nodes-events.md
index 596d25ab6..825844ddd 100644
--- a/ej2-react/diagram/nodes-events.md
+++ b/ej2-react/diagram/nodes-events.md
@@ -1,20 +1,22 @@
---
layout: post
title: Events of node interaction in React Diagram component | Syncfusion®
-description: Learn here all about Nodes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+description: Learn about node interaction events in Syncfusion React Diagram including click, selection, position, size, rotate, property and collection events.
control: Events of node
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Events of nodes in React Diagram control
+# Node Interaction Events in React Diagram Component
-Diagram provides some events support for node that triggers when interacting with the node.
+The React Diagram component provides comprehensive event support for node interactions, allowing developers to respond to user actions and customize behavior during various interaction scenarios. These events are triggered when users interact with nodes through clicking, dragging, resizing, rotating, and other operations.
-## Click event
+## Click Event
-Triggers when the node is clicked. The following code example explains how to get the [`click`](https://ej2.syncfusion.com/react/documentation/api/diagram/#click) event in the diagram.
+Triggered when a user clicks on a node. This event provides access to the clicked node and mouse event details, enabling custom click handling and node-specific actions.
+
+The following code example demonstrates how to handle the [`click`](https://ej2.syncfusion.com/react/documentation/api/diagram/#click) event in the diagram:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -27,10 +29,11 @@ Triggers when the node is clicked. The following code example explains how to ge
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nEvent-cs1" %}
-## Selection change event
+## Selection Change Event
+
+Triggered when a node's selection state changes, either when selected or deselected. This event fires during both the selection process and completion, providing control over selection behavior.
-Triggers when the node is selected in diagram.
-The following code example explains how to get the [`selectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#selectionchange) event in the diagram.
+The following code example shows how to handle the [`selectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#selectionchange) event:
{% tabs %}
@@ -44,8 +47,7 @@ The following code example explains how to get the [`selectionChange`](https://e
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nEvent-cs2" %}
- You can prevent selection by setting the `cancel` property of [`SelectionChangeEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/iSelectionChangeEventArgs/) to true, as shown in the code snippet below.
-
+Selection can be prevented by setting the `cancel` property[`SelectionChangeEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/iSelectionChangeEventArgs/) to **true**, as shown in the following code:
```ts
selectionChange: function (args: ISelectionChangeEventArgs) {
if (args.state == 'Changing') {
@@ -56,10 +58,11 @@ The following code example explains how to get the [`selectionChange`](https://e
```
-## Position change event
+## Position Change Event
-While dragging the node through interaction, the position change event can be used to do the customization.
-The following code example explains how to get the [`positionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#positionchange) event in the diagram.
+Triggered during node dragging operations, providing real-time position updates as users move nodes. This event enables position validation, snap-to-grid functionality, and custom drag behavior.
+
+The following code example demonstrates how to handle the [`positionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#positionchange) event:
{% tabs %}
@@ -73,7 +76,7 @@ The following code example explains how to get the [`positionChange`](https://ej
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nEvent-cs3" %}
- You can prevent dragging by setting the `cancel` property of [`DraggingEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/iDraggingEventArgs/) to true, as shown in the code snippet below.
+Dragging can be prevented by setting the `cancel` property of [`DraggingEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/iDraggingEventArgs/) to **true**:
```ts
positionChange: function (args: IDraggingEventArgs) {
@@ -85,10 +88,11 @@ The following code example explains how to get the [`positionChange`](https://ej
```
-## Size change event
+## Size Change Event
+
+Triggered during node resizing operations when users interact with resize handles. This event provides access to the new dimensions and allows for size constraints and validation.
-While resizing the node during the interaction, the size change event can be used to do the customization.
-The following code example explains how to get the [`sizeChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#sizechange) event in the diagram.
+The following code example shows how to handle the [`sizeChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#sizechange) event:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -101,7 +105,7 @@ The following code example explains how to get the [`sizeChange`](https://ej2.sy
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nEvent-cs4" %}
- You can prevent resizing by setting the `cancel` property of [`SizeChangeEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/isizechangeeventargs/) to true, as shown in the code snippet below.
+Resizing can be prevented by setting the `cancel` property of[`SizeChangeEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/isizechangeeventargs/) to **true**:
```ts
sizeChange: function (args: ISizeChangeEventArgs) {
@@ -113,10 +117,11 @@ The following code example explains how to get the [`sizeChange`](https://ej2.sy
```
-## Rotate change event
+## Rotate Change Event
-While rotating the node during the interaction, the rotate change event can be used to do the customization.
-The following code example explains how to get the [`rotateChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#rotatechange) event in the diagram.
+Triggered during node rotation operations when users interact with the rotation handle. This event enables rotation constraints and custom rotation behavior.
+
+The following code example demonstrates how to handle the [`rotateChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#rotatechange) event:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -129,7 +134,7 @@ The following code example explains how to get the [`rotateChange`](https://ej2.
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nEvent-cs5" %}
- You can prevent rotation by setting the `cancel` property of [`RotationEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/irotationeventargs/) to true, as shown in the code snippet below.
+Rotation can be prevented by setting the `cancel` property of[`RotationEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/irotationeventargs/) to **true**:
```ts
rotateChange: function (args: IRotationEventArgs) {
@@ -141,9 +146,11 @@ The following code example explains how to get the [`rotateChange`](https://ej2.
```
-## Property change event
+## Property Change Event
+
+Triggered when any property of a node is modified programmatically or through user interaction. This event is useful for tracking changes and implementing custom validation logic.
-Triggers when there is any property change occurred for the node. The following code example explains how to get the [`propertyChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#propertychange) event in the diagram.
+The following code example shows how to handle the [`propertyChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#propertychange) event:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -156,10 +163,11 @@ Triggers when there is any property change occurred for the node. The following
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nEvent-cs6" %}
-## Collection change event
+## Collection Change Event
-Triggers when the node is added or removed in diagram dynamically.
-The following code example explains how to get the [`collectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#collectionchange) event in the diagram.
+Triggered when nodes are added to or removed from the diagram dynamically. This event provides control over diagram modifications and enables validation before collection changes occur.
+
+The following code example demonstrates how to handle the [`collectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#collectionchange) event:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -172,7 +180,7 @@ The following code example explains how to get the [`collectionChange`](https://
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nEvent-cs7" %}
-You can prevent changes to the diagram collection, such as adding or deleting nodes, by setting the `cancel` property of [`CollectionChangeEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/icollectionchangeeventargs/) to true, as shown in the code snippet below.
+Collection changes can be prevented by setting the `cancel` property of[`CollectionChangeEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/icollectionchangeeventargs/) to **true**:
```ts
collectionChange: function (args: ICollectionChangeEventArgs) {
@@ -186,19 +194,21 @@ You can prevent changes to the diagram collection, such as adding or deleting no
## Mouse Events
-### Mouse enter event
+The diagram component provides mouse interaction events that trigger when users hover over or move the mouse cursor in relation to node surfaces.
+
+### Mouse Enter Event
-The [`mouseEnter`](https://ej2.syncfusion.com/react/documentation/api/diagram/#mouseenter) is triggered when the mouse enters the node surface.
+The [`mouseEnter`](https://ej2.syncfusion.com/react/documentation/api/diagram/#mouseenter) event is triggered when the mouse cursor enters a node's boundary area.
-### Mouse over event
+### Mouse Over Event
-The [`mouseOver`](https://ej2.syncfusion.com/react/documentation/api/diagram/#mouseover) is triggered when the mouse hover over the node surface.
+The [`mouseOver`](https://ej2.syncfusion.com/react/documentation/api/diagram/#mouseover) event is triggered when the mouse cursor hovers over a node's surface area.
-### Mouse leave event
+### Mouse Leave Event
-The [`mouseLeave`](https://ej2.syncfusion.com/react/documentation/api/diagram/#mouseleave) is triggered when the mouse leaves the node surface.
+The [`mouseLeave`](https://ej2.syncfusion.com/react/documentation/api/diagram/#mouseleave) event is triggered when the mouse cursor leaves a node's boundary area.
-The following code example shows how to handle these events in the diagram and change the color of a node based on these events:
+The following code example demonstrates how to handle these mouse events and implement visual feedback by changing node colors based on mouse interactions:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/nodes-expandAndCollapse.md b/ej2-react/diagram/nodes-expandAndCollapse.md
index 113cc54a7..5b85efaea 100644
--- a/ej2-react/diagram/nodes-expandAndCollapse.md
+++ b/ej2-react/diagram/nodes-expandAndCollapse.md
@@ -1,36 +1,41 @@
---
layout: post
title: Expand and collapse nodes in React Diagram component | Syncfusion®
-description: Learn here all about Nodes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+description: Learn how to implement expand and collapse functionality for nodes in Syncfusion® React Diagram component with customizable icons and states.
control: Expand and collapse of nodes
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Expand icon and collapse icon in React Diagram control
+# Expand and Collapse Nodes in React Diagram Component
-Diagram provides support to describe the state of the node. i.e., the node is expanded or collapsed state. The IsExpanded property of node is used to expand or collapse the children nodes.The Expand and Collapse support is used to compress the hierarchy view so that only the roots of each elements are visible.
+The React Diagram component provides built-in support for expanding and collapsing nodes, enabling users to create hierarchical views where child nodes can be hidden or shown dynamically. This functionality is particularly useful for organizational charts, mind maps, and tree structures where managing visual complexity is essential.
-The following properties of the Node are used to represent the state of the node and allows user to Expand and Collapse the desired Node:
+The expand and collapse feature allows users to:
+- Compress hierarchical views to show only root elements.
+- Toggle visibility of child nodes interactively.
+- Customize the appearance of expand and collapse icons.
+- Control the initial state of nodes programmatically.
-* ExpandIcon
+The following properties control the expand and collapse behavior of nodes:
-* CollapseIcon
+* **expandIcon** - Defines the icon displayed when a node can be expanded.
+* **collapseIcon** - Defines the icon displayed when a node can be collapsed.
-N> Icon can be created only when the node has outEdges.
+N> Icons are only created when the node has outgoing edges (outEdges).
-To explore the properties of expand and collapse icon, refer to [`expandIcon`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#expandicon) and [`collapseIcon`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#collapseicon).
+For detailed API information, refer to[`expandIcon`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#expandicon) and [`collapseIcon`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#collapseicon).
-## Customizing expand and collapse icon
+## Customizing expand and collapse icons
-### Size and shape
+### Size and shape configuration
-Set a size for an icon by using [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#height) properties.
+Define the size of icons using the [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#height) properties.
-The expandIcon’s and collapseIcon’s [`shape`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#shape) property allows to define the shape of the icon.
+The [`shape`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#shape) property of expandIcon and collapseIcon allows customization of the icon appearance.
-The following code example illustrates how to create an icon of various shapes.
+The following code example demonstrates how to create icons with various shapes:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -43,9 +48,10 @@ The following code example illustrates how to create an icon of various shapes.
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nExpandAndCollapse-cs1" %}
-### Appearance and alignment of icon
+### Styling and appearance
-Set the borderColor, borderWidth, and background color for an icon using [`borderColor`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#bordercolor), [`borderWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#borderwidth), and [`fill`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#fill) properties.
+Customize the visual appearance of icons using the following properties:
+ [`borderColor`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#bordercolor), [`borderWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#borderwidth), and [`fill`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#fill) properties.
The corner radius can be set using the [`cornerRadius`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#cornerradius) property of the icon.
@@ -53,6 +59,8 @@ The icon can be aligned relative to the node boundaries. It has margin, offset,
The [`iconColor`](https://ej2.syncfusion.com/react/documentation/api/diagram/iconShapeModel/#iconcolor) property can be used to set the strokeColor of the Icon.
+Icons can be precisely positioned relative to node boundaries using margin, offset, horizontalAlignment, and verticalAlignment settings. While combining all four alignment properties provides maximum control, it requires careful consideration of their interactions.
+
The following code example illustrates the customization of icons.
{% tabs %}
@@ -66,9 +74,13 @@ The following code example illustrates the customization of icons.
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nExpandAndCollapse-cs2" %}
-## IsExpanded
+## Managing node expansion state
+
+The[`isExpanded`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#isexpanded)property controls whether a node displays its child nodes. When set to `true`, child nodes are visible; when **false**, they are hidden.
+
+**Default value:** **true**
-[`isExpanded`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#isexpanded) property is used to defines whether the node is expanded or not. The following example demonstrate node’s `isExpanded` property. The default value of isExpanded property is true.
+The following example demonstrates how to configure the expansion state of nodes:
```ts
diff --git a/ej2-react/diagram/nodes-interaction.md b/ej2-react/diagram/nodes-interaction.md
index aa17c709b..d4b0af6d0 100644
--- a/ej2-react/diagram/nodes-interaction.md
+++ b/ej2-react/diagram/nodes-interaction.md
@@ -1,27 +1,27 @@
---
layout: post
title: Nodes in React Diagram component | Syncfusion®
-description: Learn here all about Nodes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
-control: Nodes
+description: Learn about interactive node operations in Syncfusion React Diagram component including selection, dragging, resizing, and rotation.
+control: Nodes interaction
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Node Interaction in React Diagram control
+# Node Interaction in React Diagram Component
-The diagram provides support for selecting, dragging, resizing, and rotating nodes interactively. A node can be selected by simply clicking on it, dragged by dragging it on diagram canvas, resized using the resize handle, and rotated using the rotate handle. Additionally, interactions can be performed using some public methods, which are explained below:
+The React Diagram component provides comprehensive support for interactive node operations, enabling users to select, drag, resize, rotate, and flip nodes through both mouse interactions and programmatic methods. These interactions form the foundation of dynamic diagram editing capabilities.
## Select
-You can simply click on the node to select it and click on diagram canvas to unselect it like below.
+Node selection is fundamental to diagram interaction. Users can select nodes by clicking on them and deselect by clicking on the diagram canvas.

+### Programmatic Node Selection
-### To select node programatically
-
-A node can be selected at runtime by using the [`select`](https://ej2.syncfusion.com/react/documentation/api/diagram/#select) method and the selection can be cleared in the diagram by using the [`clearSelection`](https://ej2.syncfusion.com/react/documentation/api/diagram/#clearselection) or [`unSelect`](https://ej2.syncfusion.com/react/documentation/api/diagram/#unselect) method. The following code explains how to select and clear selection in the diagram.
+Nodes can be selected at runtime by using the [`select`](https://ej2.syncfusion.com/react/documentation/api/diagram/#select) method and the selection can be cleared in the diagram by using the [`clearSelection`](https://ej2.syncfusion.com/react/documentation/api/diagram/#clearselection) or [`unSelect`](https://ej2.syncfusion.com/react/documentation/api/diagram/#unselect) method to remove specific objects from selection.
+ The following code explains how to select and clear selection in the diagram.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -33,6 +33,7 @@ A node can be selected at runtime by using the [`select`](https://ej2.syncfusion
{% endtabs %}
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nInteraction-cs1" %}
+### Selection Methods Reference
|Method | Parameter | Description|
|----|----|----|
@@ -41,13 +42,13 @@ A node can be selected at runtime by using the [`select`](https://ej2.syncfusion
## Drag
-You can simply mousedown on a node and drag it anywhere on the diagram canvas like below.
+Node dragging allows users to reposition nodes within the diagram canvas. Users can click and hold a node, then drag it to any location on the canvas.

-### To drag node programatically
+### Programmatic Node Dragging
-A node can be dragged at runtime by using the [`drag`](https://ej2.syncfusion.com/react/documentation/api/diagram/#drag) method. The following code explains how to drag the node by using the drag method.
+Nodes can be moved programmatically using the [`drag`](https://ej2.syncfusion.com/react/documentation/api/diagram/#drag) method, which accepts the target object and new position coordinates.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -62,13 +63,13 @@ A node can be dragged at runtime by using the [`drag`](https://ej2.syncfusion.co
## Resize
-When we select a node a resize handle will appear on all the sides of the node. We can resize the node by clicking and dragging the resize handle.
+When a node is selected, resize handles appear on all sides, allowing users to modify the node's dimensions by clicking and dragging these handles.

-### To resize node programatically
+### Programmatic Node Resizing
-A node can be resized at runtime by using the [`scale`](https://ej2.syncfusion.com/react/documentation/api/diagram/#scale) method. The following code explains how to resize the node by using the scale method.
+Node dimensions can be modified at runtime using the [`scale`](https://ej2.syncfusion.com/react/documentation/api/diagram/#scale) method, which applies scaling factors to adjust the node size proportionally.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -83,13 +84,13 @@ A node can be resized at runtime by using the [`scale`](https://ej2.syncfusion.c
## Rotate
-A node can be rotated interactively by clicking and dragging the rotate handle of the node.
+Node rotation is performed interactively by clicking and dragging the rotate handle that appears when a node is selected.

-### To rotate node programatically
+### Programmatic Node Rotation
-A node can be rotated at runtime by using the [`rotate`](https://ej2.syncfusion.com/react/documentation/api/diagram/#rotate) method. The following code explains how to rotate the node by using the rotate method.
+Nodes can be rotated at runtime using the [`rotate`](https://ej2.syncfusion.com/react/documentation/api/diagram/#rotate) method, which accepts the target object and rotation angle in degrees.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -104,7 +105,9 @@ A node can be rotated at runtime by using the [`rotate`](https://ej2.syncfusion.
## Flip
-The diagram Provides support to flip the node. [`flip`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#flip) is performed to
+The diagram component supports node flipping operations to create mirrored images of nodes. The [`flip`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#flip) property controls the flip direction and behavior.
+
+### Flip Directions
give the mirrored image of the original element.
The flip types are as follows:
@@ -117,7 +120,7 @@ The flip types are as follows:
* Both
[`Both`](https://ej2.syncfusion.com/react/documentation/api/diagram/flipDirection/) which involves both vertical and horizontal changes of the element.
-The following code illustrates how to provide the mirror image of the original element.
+The following example demonstrates how to apply flip transformations to nodes:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -132,9 +135,10 @@ The following code illustrates how to provide the mirror image of the original e
>Note: The flip is also applicable for group and BPMN shapes.
-### Update flip at runtime
+### Runtime Flip Updates
+
+Node flip properties can be updated dynamically at runtime using the `^` operator, which allows toggling flip states by applying the same flip direction multiple times.
-You can dynamically update the flip for a node at runtime using the `^` operator. This operator allows you to apply the same flip direction multiple times, toggling the node's orientation effectively.
The following example demonstrates how to update the flip for a node dynamically:
{% tabs %}
@@ -149,9 +153,9 @@ The following example demonstrates how to update the flip for a node dynamically
{% previewsample "page.domainurl/code-snippet/diagram/nodes/node-cs4-flip" %}
-### Flip modes
+### Flip Modes
-The [`flipMode`](https://ej2.syncfusion.com/angular/documentation/api/diagram/flipMode/) is used to control the behavior of the flip object whether to flip the object along with the port and label.
+The [`flipMode`](https://ej2.syncfusion.com/react/documentation/api/diagram/flipMode/) property controls which elements are affected during flip operations, determining whether ports, labels, and label text are flipped along with the node.
| FlipMode | Description |
| -------- | -------- |
@@ -164,7 +168,9 @@ The [`flipMode`](https://ej2.syncfusion.com/angular/documentation/api/diagram/fl
|PortAndLabelText| It flips the port and label text along with the object.|
|LabelAndLabelText| It flips the label and label text along with the Object.|
-Below are examples of a node undergoing various FlipModes in different flip directions.
+### Flip Mode Visual Examples
+
+The following table demonstrates how different flip modes affect node appearance across various flip directions:
| Flip Direction | Flip Mode | Default Node | Flipped Node |
| -------- | -------- | -------- | -------- |
diff --git a/ej2-react/diagram/nodes-positioning.md b/ej2-react/diagram/nodes-positioning.md
index a75bafd34..45f719a78 100644
--- a/ej2-react/diagram/nodes-positioning.md
+++ b/ej2-react/diagram/nodes-positioning.md
@@ -8,12 +8,14 @@ documentation: ug
domainurl: ##DomainURL##
---
-# Positioning a node in React Diagram control
+# Positioning a Node in in React Diagram Component
To customize the position of nodes in the React Diagram component, refer to the video link below.
{% youtube "https://www.youtube.com/watch?v=pn02S_rwupw" %}
+Node positioning in the React Diagram component allows precise control over where nodes appear on the diagram canvas. Understanding positioning fundamentals enables developers to create well-organized diagrams with nodes placed exactly where needed.
+
## Position
* Position of a node is controlled by using its [`offsetX`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#offsetx) and [`offsetY`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#offsety) properties. By default, these offset properties represent the distance between the origin of the diagram’s page and node’s center point.
@@ -25,13 +27,15 @@ To customize the position of nodes in the React Diagram component, refer to the
* Rotation of a node is controlled by using its [`rotateAngle`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#rotateangle) property.
-The following table illustrates how pivot relates offset values with node boundaries.
+### Understanding Pivot Points
+
+The pivot point determines which part of the node the offset coordinates reference. The following table illustrates how different pivot values affect node positioning:
-| Pivot | Offset |
+| Pivot | Offset Behavior |
|-------- | -------- |
| (0.5,0.5)| offsetX and offsetY values are considered as the node’s center point. |
-| (0,0) | offsetX and offsetY values are considered as the top-left corner of the node. |
-| (1,1) | offsetX and offsetY values are considered as the bottom-right corner of the node. |
+| (0,0) | offsetX and offsetY values position the node's top-left corner |
+| (1,1) | offsetX and offsetY values position the node's bottom-right corner |
The following code illustrates how to change the `pivot` value.
@@ -46,9 +50,11 @@ The following code illustrates how to change the `pivot` value.
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nPositioning-cs1" %}
-## Minimum and maximum size for nodes.
+## Minimum and Maximum size for nodes.
+
+The size constraints ensure nodes maintain appropriate dimensions during resizing operations. The [`minWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#minwidth) and [`minHeight`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#minheight) properties define the smallest allowable size for a node during resize operations. Similarly, the `maxWidth` and `maxHeight` properties define the largest allowable size.
-The [`minWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#minwidth) and [`minHeight`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#minheight) properties of node allows you to control the minimum size of the node while resizing. Similarly, the [`maxWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#maxwidth) and [`maxHeight`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#maxheight) properties of node allows you to control the maximum size of the node while resizing.
+These constraints are particularly useful when creating diagrams where nodes need to maintain specific size ranges for visual consistency or functional requirements.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/nodes.md b/ej2-react/diagram/nodes.md
index 85fa79c15..3e69c165f 100644
--- a/ej2-react/diagram/nodes.md
+++ b/ej2-react/diagram/nodes.md
@@ -1,30 +1,35 @@
---
layout: post
-title: Nodes in React Diagram component | Syncfusion®
-description: Learn here all about Nodes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Nodes in React Diagram Component | Syncfusion®
+description: Learn here all about Nodes in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Nodes
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Nodes in React Diagram component
+# Nodes in React Diagram Component
-Nodes are graphical objects used to visually represent the geometrical information, process flow, internal business procedure, entity, or any other kind of data, and it represents the functions of a complete system regarding to how it interacts with external entities.
+Nodes are graphical objects that visually represent entities, processes, data flow, or any business logic within diagrams. They serve as the fundamental building blocks for creating flowcharts, organizational charts, network diagrams, and other visual representations. Each node can be customized with different shapes, sizes, colors, and interactive behaviors to suit specific diagram requirements.

-## Create node
+## Node Fundamentals
-A node can be created and added to the diagram either programmatically or interactively. The [`id`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#id) property of a node is used to define its unique identifier and can later be used to find the node at runtime for customization. Nodes are stacked on the diagram area from bottom to top in the order they are added.
+Before creating nodes, understanding their core properties helps in effective diagram development:
-N> When setting a Node's ID, ensure that it does not contain white spaces, does not start with numbers or special characters, and does not include special characters like underscores (_) or spaces.
+- **Position**: Defined by `offsetX` and `offsetY` properties for precise placement.
+- **Size**: Controlled through `width` and `height` properties.
+- **Identification**: Each node requires a unique `id` for runtime operations.
+- **Stacking**: Nodes are layered from bottom to top based on addition order.
-### Add node through nodes collection
+## Creating Nodes
-To create a node, define the [`node`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/) object and add that to [`nodes`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeModel/) collection of the [`diagram model`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramModel/). The following code example illustrates how to add a node to the diagram.
+### Add Nodes through Nodes Collection
+
+To create a node, define the [`node`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#node) object and add it to the [`nodes`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeModel/) collection of the diagram model. The [`id`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#id) property serves as the unique identifier for runtime operations and customization.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -39,91 +44,96 @@ To create a node, define the [`node`](https://ej2.syncfusion.com/react/documenta
N> Node id should not begin with numbers(should begin with a letter). Node Id should be unique for all the shapes and connectors.
-### Add/Remove node at runtime
-
-Nodes can be added at runtime by using public method, [`add`](https://ej2.syncfusion.com/react/documentation/api/diagram/#add) and can be removed at runtime by using public method, [`remove`](https://ej2.syncfusion.com/react/documentation/api/diagram/#remove). On adding node at runtime, the nodes collection is changed and the [`collectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#collectionchange) event will trigger.
+### Create Node from Data Source
-The following code illustrates how to add a node.
+Nodes can be generated automatically using the dataSource property. Default properties for these nodes are retrieved from([`getNodeDefaults`](https://ej2.syncfusion.com/react/documentation/api/diagram/#getnodedefaults)) settings. For detailed information about data binding, refer to [`DataBinding`](./data-binding).
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
-{% include code-snippet/diagram/nodes/nodes-cs2/app/index.jsx %}
+{% include code-snippet/diagram/nodes/nodes-cs5/app/index.jsx %}
{% endhighlight %}
{% highlight ts tabtitle="index.tsx" %}
-{% include code-snippet/diagram/nodes/nodes-cs2/app/index.tsx %}
+{% include code-snippet/diagram/nodes/nodes-cs5/app/index.tsx %}
{% endhighlight %}
{% endtabs %}
+
+{% previewsample "page.domainurl/code-snippet/diagram/nodes/nodes-cs5" %}
- {% previewsample "page.domainurl/code-snippet/diagram/nodes/nodes-cs2" %}
-
-### Add collection of nodes at runtime
-
-* The collection of nodes can be dynamically added using [`addElements`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addelements) method.Each time an element is added to the diagram canvas, the [`collectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram#collectionchange) event will be triggered.
+### Add Nodes from Symbol Palette
-The following code illustrates how to add nodes collection at run time.
+Nodes can be predefined in a symbol palette and dragged into the diagram as needed. This approach provides users with a library of reusable components. For comprehensive guidance on symbol palette integration, refer to [`Symbol Palette`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPaletteModel).
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
-{% include code-snippet/diagram/nodes/nodes-cs3/app/index.jsx %}
+{% include code-snippet/diagram/nodes/nodes-cs4/app/index.jsx %}
{% endhighlight %}
{% highlight ts tabtitle="index.tsx" %}
-{% include code-snippet/diagram/nodes/nodes-cs3/app/index.tsx %}
+{% include code-snippet/diagram/nodes/nodes-cs4/app/index.tsx %}
{% endhighlight %}
{% endtabs %}
-{% previewsample "page.domainurl/code-snippet/diagram/nodes/nodes-cs3" %}
+{% previewsample "page.domainurl/code-snippet/diagram/nodes/nodes-cs4" %}
-### Add node from palette
-Nodes can be predefined and added to the palette, and can be dropped into the diagram when needed. For more information
-about adding nodes from symbol palette, refer to [`Symbol Palette`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPaletteModel).
+### Draw Nodes Interactively
+
+To enable interactive node drawing, activate the drawing tool by setting `DrawOnce` or `ContinuousDraw` to the [`tool`](https://ej2.syncfusion.com/react/documentation/api/diagram/#tool) property and configure the node template using the [`drawingObject`](https://ej2.syncfusion.com/react/documentation/api/diagram/#drawingobject) property.
+
+The following code example illustrates how to draw a rectangle at runtime.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
-{% include code-snippet/diagram/nodes/nodes-cs4/app/index.jsx %}
+{% include code-snippet/diagram/nodes/nodes-cs6/app/index.jsx %}
{% endhighlight %}
{% highlight ts tabtitle="index.tsx" %}
-{% include code-snippet/diagram/nodes/nodes-cs4/app/index.tsx %}
+{% include code-snippet/diagram/nodes/nodes-cs6/app/index.tsx %}
{% endhighlight %}
{% endtabs %}
-{% previewsample "page.domainurl/code-snippet/diagram/nodes/nodes-cs4" %}
+{% previewsample "page.domainurl/code-snippet/diagram/nodes/nodes-cs6" %}
+
+## Runtime Node Operations
-### Create node through data source
+### Add and Remove Individual Nodes
-Nodes can be generated automatically with the information provided through dataSource property. The default properties for these nodes are fetched from default settings ([`getNodeDefaults`](https://ej2.syncfusion.com/react/documentation/api/diagram/#getnodedefaults)). For more information about data source, refer to [`DataBinding`](./data-binding).
+Nodes can be dynamically added using the [`add`](https://ej2.syncfusion.com/react/documentation/api/diagram/#add) method and removed using the [`remove`](https://ej2.syncfusion.com/react/documentation/api/diagram/#remove) method. Both operations trigger the [`collectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/#collectionchange) event, allowing for custom handling of diagram modifications.
+
+The following code illustrates how to add a node.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
-{% include code-snippet/diagram/nodes/nodes-cs5/app/index.jsx %}
+{% include code-snippet/diagram/nodes/nodes-cs2/app/index.jsx %}
{% endhighlight %}
{% highlight ts tabtitle="index.tsx" %}
-{% include code-snippet/diagram/nodes/nodes-cs5/app/index.tsx %}
+{% include code-snippet/diagram/nodes/nodes-cs2/app/index.tsx %}
{% endhighlight %}
{% endtabs %}
-
-{% previewsample "page.domainurl/code-snippet/diagram/nodes/nodes-cs5" %}
-### Draw nodes
+ {% previewsample "page.domainurl/code-snippet/diagram/nodes/nodes-cs2" %}
+
+### Add Multiple Nodes Simultaneously
-Nodes can be interactively drawn by clicking and dragging the diagram surface.
+Collections of nodes can be efficiently added using the[`addElements`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addelements) method. This approach is optimal for bulk operations and triggers the `collectionChange` event for each added element.
-To draw a shape, you have to activate the drawing tool by setting `DrawOnce` or `ContinuousDraw` to the [`tool`](https://ej2.syncfusion.com/react/documentation/api/diagram/#tool) property and you need to set the `node` object by using the [`drawingObject`](https://ej2.syncfusion.com/react/documentation/api/diagram/#drawingobject) property. The following code example illustrates how to draw a rectangle at runtime.
+The following code illustrates how to add nodes collection at run time.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
-{% include code-snippet/diagram/nodes/nodes-cs6/app/index.jsx %}
+{% include code-snippet/diagram/nodes/nodes-cs3/app/index.jsx %}
{% endhighlight %}
{% highlight ts tabtitle="index.tsx" %}
-{% include code-snippet/diagram/nodes/nodes-cs6/app/index.tsx %}
+{% include code-snippet/diagram/nodes/nodes-cs3/app/index.tsx %}
{% endhighlight %}
{% endtabs %}
-{% previewsample "page.domainurl/code-snippet/diagram/nodes/nodes-cs6" %}
+{% previewsample "page.domainurl/code-snippet/diagram/nodes/nodes-cs3" %}
+
-## Update node at runtime
-You can modify any node properties at runtime, and the changes will be instantly reflected. For example, here you can change the size and color of the node.
+
+### Update Node Properties
+
+Node properties can be modified at runtime with immediate visual updates. Changes take effect instantly, allowing for dynamic diagram manipulation based on user interactions or data updates.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -136,11 +146,11 @@ You can modify any node properties at runtime, and the changes will be instantly
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nodes-cs7" %}
-N> Once the property is updated, you should call the [`dataBind`](./data-binding) to reflect the changes instantly.
+N> Call the [`dataBind`](./data-binding) `dataBind` method after property updates to ensure immediate reflection of changes.
-## Clone node at runtime
+### Clone Node at Runtime
-Cloning a node creates a new node instance with identical properties and attributes. You can clone a node using the [`copy`](https://ej2.syncfusion.com/react/documentation/api/diagram/#copy) and [`paste`](https://ej2.syncfusion.com/react/documentation/api/diagram/#paste) public methods of the diagram model.
+Node cloning creates new instances with identical properties and attributes. Use the [`copy`](https://ej2.syncfusion.com/react/documentation/api/diagram/#copy) and [`paste`](https://ej2.syncfusion.com/react/documentation/api/diagram/#paste) methods to duplicate existing nodes programmatically.
The following code example illustrates how to clone node at runtime
@@ -156,15 +166,17 @@ The following code example illustrates how to clone node at runtime
{% previewsample "page.domainurl/code-snippet/diagram/nodes/nodes-cs8" %}
-## Add nodes from tree view
+## Advanced Node Integration
+
+### Import Nodes from External Components
-By customizing the [`dragEnter`](https://ej2.syncfusion.com/react/documentation/api/diagram/#dragenter) functionality, you can allow elements from other components, such as the tree view, to be converted into nodes based on the data of the dragged element.
+Custom [`dragEnter`](https://ej2.syncfusion.com/react/documentation/api/diagram/#dragenter) functionality enables conversion of elements from other components, such as tree views, into diagram nodes based on the dragged element's data properties.
## See Also
-* [How to add annotations to the node](./labels)
-* [How to add ports to the node](./ports)
-* [How to enable/disable the behavior of the node](./constraints)
-* [How to add nodes to the symbol palette](./symbol-palette)
-* [How to edit the node visual interface](./interaction#selection)
-* [How to create diagram nodes using drawing tools](./tools)
+* [How to add annotations to the node.](./labels)
+* [How to add ports to the node.](./ports)
+* [How to enable/disable the behavior of the node.](./constraints)
+* [How to add nodes to the symbol palette.](./symbol-palette)
+* [How to edit the node visual interface.](./interaction#selection)
+* [How to create diagram nodes using drawing tools.](./tools)
diff --git a/ej2-react/diagram/org-chart.md b/ej2-react/diagram/org-chart.md
index 17b39f29b..bf01fcc50 100644
--- a/ej2-react/diagram/org-chart.md
+++ b/ej2-react/diagram/org-chart.md
@@ -1,22 +1,21 @@
---
layout: post
-title: Org-chart layout in React Diagram component | Syncfusion®
-description: Learn here all about Org-chart layout in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Org-chart layout in React Diagram Component | Syncfusion®
+description: Learn here all about Org-chart layout in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Org-chart layout
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Organizational Chart layout in React Diagram control
+# Organizational Chart Layout in React Diagram Component
-An organizational chart is a diagram that displays the structure of an organization and relationships. To create an organizational chart, the [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#type) of layout should be set as an `OrganizationalChart`.
+An organizational chart is a diagram that displays the hierarchical structure of an organization, showing reporting relationships and roles within the company. The React Diagram component provides specialized support for creating professional organizational charts through automatic layout algorithms. To create an organizational chart, set the [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#type) of layout should be set as an **OrganizationalChart**.
-## Organizational chart with DataSource
-
-The following code example illustrates how to create an organizational chart with DataSource.
+## Organizational Chart with DataSource
+This approach is ideal when working with dynamic data from databases, APIs, or when the organizational structure changes frequently. The component automatically generates nodes and connectors based on the provided data structure.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -31,10 +30,10 @@ The following code example illustrates how to create an organizational chart wit
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/organizationalchart-cs1" %}
->Note: If you want to use Organizational chart layout in diagram, you need to inject HierarchicalTree module along with DataBinding module in the diagram.
+>Note: When using organizational chart layout, both HierarchicalTree and DataBinding modules must be injected into the diagram component.
-## Organizational chart with nodes and connectors
+## Organizational Chart with Nodes and Connectors
You can render an org-chart layout without using DataSource. The following code demonstrates how to render an org-chart layout without using data source.
@@ -53,15 +52,20 @@ You can render an org-chart layout without using DataSource. The following code

-## GetLayout info
+## Advanced Layout Customization with getLayoutInfo
+
+Organizational chart layout starts parsing from root and iterate through all its child elements. The [`getLayoutInfo`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#getlayoutinfo) method provides granular control over how each subtree within the organizational chart is arranged. This method is invoked for every node during the layout process, allowing customization of orientation, alignment, spacing, and special node types like assistants.
+
+The organizational chart layout engine parses the hierarchy starting from the root node and processes each subtree. By overriding the `getLayoutInfo` method, developers can customize the arrangement of child nodes based on specific business requirements.
-Organizational chart layout starts parsing from root and iterate through all its child elements. The [`getLayoutInfo`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#getlayoutinfo) method provides necessary information of a node’s children and the way to arrange (direction, orientation, offsets, etc.) them. The arrangements can be customized by overriding this function as explained.
+### getLayoutInfo Parameters
-Set chart orientations, chart types, and offset to be left between parent and child nodes by overriding the `getLayoutInfo` method. The `getLayoutInfo` method is called to configure every subtree of the organizational chart. It takes the following arguments.
+The `getLayoutInfo` method accepts the following parameters:
- * node: Parent node to that options are to be customized.
- * options: Object to set the customizable properties.
+- **node**: The parent node for which layout options are being configured.
+- **options**: Configuration object containing customizable layout properties.
+### Layout Options Properties
The following table illustrates the properties that “options” argument takes.
@@ -76,7 +80,9 @@ The following table illustrates the properties that “options” argument takes
|options.enableRouting|By default, connections are routed based on the chart type and orientations. This property gets or sets whether default routing is to be enabled or disabled.|true|
|options.rows|Sets the number of rows on which the child nodes will be arranged. Applicable only for balanced type horizontal tree.|Number|
-The following table illustrates the different chart orientations and chart types.
+### Orientation and Alignment Options
+
+The following table describes the available chart orientations and their corresponding alignment types:
|Orientation|Type|Description|Example|
| -------- | ----------- | ------------- |------|
@@ -89,10 +95,9 @@ The following table illustrates the different chart orientations and chart types
||Alternate|Arranges the children vertically at both left and right sides of the parent.||
-### SubTree horizontal orientation
-
-The following example shows how to utilize the `getLayoutInfo` function to customize the sub tree alignment in horizontal orientation.
+### Horizontal Subtree Orientation Example
+The following example demonstrates customizing subtree alignment for horizontal organizational structures:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -106,11 +111,9 @@ The following example shows how to utilize the `getLayoutInfo` function to custo
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/organizationalchart-cs3" %}
+### Vertical Subtree Orientation Example
-### SubTree vertical orientation
-
-The following code example illustrates how to set the vertical arrangement to the leaf level trees.
-
+This example shows how to implement vertical arrangement for leaf-level organizational trees:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -125,9 +128,9 @@ The following code example illustrates how to set the vertical arrangement to th
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/organizationalchart-cs4" %}
-### Assistant
+### Assistant Nodes
-Assistants are child item that have a different relationship with the parent node. They are laid out in a dedicated part of the tree. A node can be specified as an assistant of its parent by adding it to the `assistants` property of the argument “options”.
+Assistant nodes represent positions with specialized relationships to their parent, such as executive assistants or advisor's. These nodes are positioned in a dedicated area separate from regular child nodes. To designate a node as an assistant, add it to the **assistants** collection within the `getLayoutInfo` options parameter.
The following code example illustrates how to add assistants to layout.
@@ -147,4 +150,12 @@ The following code example illustrates how to add assistants to layout.

->Note: An Assistant node cannot have any child nodes
+>Note: Assistant nodes cannot have child nodes and serve as terminal positions in the organizational hierarchy.
+
+## Best Practices
+
+- Use the DataSource approach for dynamic organizational structures that may change frequently.
+- Implement the manual approach when requiring custom node designs or static hierarchies.
+- Consider using assistant nodes for specialized roles like executive assistants or advisory positions.
+- Apply appropriate orientation and alignment settings based on the size and complexity of the organization.
+- Test layout performance with large datasets and consider implementing virtualization for extensive organizational charts.
\ No newline at end of file
diff --git a/ej2-react/diagram/overview.md b/ej2-react/diagram/overview.md
index 65626f027..32bda361e 100644
--- a/ej2-react/diagram/overview.md
+++ b/ej2-react/diagram/overview.md
@@ -1,30 +1,35 @@
---
layout: post
title: Overview in React Diagram component | Syncfusion®
-description: Learn here all about Overview in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+description: Learn how to implement and use the Overview component in Syncfusion® React Diagram for navigation, zooming, and panning in large diagrams.
control: Overview
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Overview in React Diagram component
+# Overview Component in React Diagram Component
-The Overview control allows you to see a preview or an overall view of the entire content of a diagram. This helps you to grasp the overall picture of a large diagram and navigate, pan, or zoom to a specific position on the page.
+The Overview component provides a miniature preview of the entire diagram content, enabling efficient navigation and viewport management for large diagrams. This component displays a scaled-down version of the diagram with a highlighted rectangle representing the current viewport, allowing users to quickly navigate to specific areas without manual zooming and panning.
-## Usage scenario
+## When to Use Overview
-When working on a very large diagram, it can be challenging to know which part you are actually focusing on or to navigate from one section to another. One solution for navigation is to zoom out to view the entire diagram and locate your position. Then, you can zoom in on the specific area you need. However, this method is not ideal for frequent navigation.
+The Overview component is essential when working with:
-The Overview control addresses these issues by providing a preview, or overall view, of the entire diagram. A rectangle indicates the viewport of the diagram, making navigation easy by dragging this rectangle to the desired section.
+* Large diagrams that exceed the visible viewport.
+* Complex flowcharts or organizational charts requiring frequent navigation.
+* Multi-section diagrams where users need to jump between different areas.
+* Applications where users need spatial awareness of their current position within the diagram.
-## Create overview
-To create an overview, the [`sourceID`](https://ej2.syncfusion.com/react/documentation/api/overview/overviewModel/#sourceid) property of the overview should be set with the corresponding diagram Id for the overall view.
+## Create Overview Component
-The [`width`](https://ej2.syncfusion.com/react/documentation/api/overview/overviewModel/#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/overview/overviewModel/#height) properties of the overview allow you to define its size.
+To implement an overview, configure the [`sourceID`](https://ej2.syncfusion.com/react/documentation/api/overview/overviewModel/#sourceid) property to reference the target diagram's identifier. This establishes the connection between the overview and the main diagram.
-The following code illustrates how to create an overview:
+Define the overview dimensions using the [`width`](https://ej2.syncfusion.com/react/documentation/api/overview/overviewModel/#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/overview/overviewModel/#height) properties to ensure optimal visibility and performance.
+
+
+The following code demonstrates basic overview implementation:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -37,16 +42,18 @@ The following code illustrates how to create an overview:
{% previewsample "page.domainurl/code-snippet/diagram/overView/es5Node-cs2" %}
-### Overview interactions
+## Overview Interactions
+
+The overview displays the current viewport as a red rectangle overlay. This rectangle serves as an interactive control for diagram navigation and zoom operations.
-In the overview, the viewport of the diagram is highlighted with a red color rectangle. You can zoom and pan the diagram by interacting with this rectangle.
+### Available Interactions
-You can interact with the overview as follows:
+* **Resize the rectangle**: Adjusts diagram zoom level proportionally.
+* **Drag the rectangle**: Pans the diagram to follow rectangle movement.
+* **Click on a position**: Instantly navigates to the clicked location.
+* **Click and drag selection**: Defines a specific region for navigation and zoom.
-* Resize the rectangle: Zooms in/out of the diagram.
-* Drag the rectangle: Pans the diagram.
-* Click on a position: Navigates to the clicked region.
-* Select a specific region by clicking and dragging: Navigates to the specified region.
+### Interactive Navigation Example
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -59,6 +66,6 @@ You can interact with the overview as follows:
{% previewsample "page.domainurl/code-snippet/diagram/overView/es5Node-cs1" %}
-The following Gif image displays the interactions with overview.
+The following demonstration shows overview interaction capabilities:
-
+
\ No newline at end of file
diff --git a/ej2-react/diagram/page-settings.md b/ej2-react/diagram/page-settings.md
index d6f0bc063..3367d9f3c 100644
--- a/ej2-react/diagram/page-settings.md
+++ b/ej2-react/diagram/page-settings.md
@@ -1,14 +1,14 @@
---
layout: post
-title: Page settings in React Diagram component | Syncfusion®
-description: Learn here all about Page settings in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Page settings in React Diagram Component | Syncfusion®
+description: Learn here all about Page settings in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Page settings
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Page settings in React Diagram component
+# Page Settings in React Diagram Component
Page settings allow customization of the appearance, size, and orientation of the diagram page.
@@ -16,11 +16,11 @@ To customize the diagram page settings, insert page breaks, display multiple pag
{% youtube "https://www.youtube.com/watch?v=pn02S_rwupw" %}
-## Page size and appearance
+## Page Size and Appearance
-The [`width`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pageSettings/#width) and [`height`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pageSettings/#height) properties in page settings determine the size of the page. Additionally, the [`background`](https://helpej2.syncfusion.com/react/documentation/api/diagram/backgroundModel/) property allows customization of the page's appearance. The [`color`](https://helpej2.syncfusion.com/react/documentation/api/diagram/backgroundModel/#color) property of background is used to define the color of the page. The [`margin`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/) property defines the page margins.
+The diagram page dimensions are controlled through the [`width`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pageSettings/#width) and [`height`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pageSettings/#height) properties in page settings. The page appearance can be customized using the [`background`](https://helpej2.syncfusion.com/react/documentation/api/diagram/backgroundModel/) property, which includes options for setting the background [`color`](https://helpej2.syncfusion.com/react/documentation/api/diagram/backgroundModel/#color) and other visual properties. The [`margin`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/) property defines spacing around the page content.
-To explore those properties, refer to [`Page Settings`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pageSettingsModel/)
+For comprehensive details on all available properties, refer to the [`Page Settings`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pageSettingsModel/)
The following example shows the customization of page settings.
@@ -35,9 +35,9 @@ The following example shows the customization of page settings.
{% previewsample "page.domainurl/code-snippet/diagram/pagesettings/es5pagesettings-cs1" %}
-## Set background image
+## Set Background Image
-A background image can be attached to the page by using the [`source`](https://helpej2.syncfusion.com/react/documentation/api/diagram/backgroundModel/#source) property of [`background`](https://helpej2.syncfusion.com/react/documentation/api/diagram/backgroundModel/) . The [`scale`](https://helpej2.syncfusion.com/react/documentation/api/diagram/backgroundModel/#scale) property adjusts how the background image stretches, while the [`align`](https://helpej2.syncfusion.com/react/documentation/api/diagram/backgroundModel/#align) property aligns the image within the diagram page.
+A background image can be attached to the page by using the [`source`](https://helpej2.syncfusion.com/react/documentation/api/diagram/backgroundModel/#source) property of `background` . The [`scale`](https://helpej2.syncfusion.com/react/documentation/api/diagram/backgroundModel/#scale) property adjusts how the background image stretches, while the [`align`](https://helpej2.syncfusion.com/react/documentation/api/diagram/backgroundModel/#align) property determines the image positioning within the diagram page boundaries.
The following code illustrates how to set background image to the diagram page.
@@ -52,14 +52,16 @@ The following code illustrates how to set background image to the diagram page.
{% previewsample "page.domainurl/code-snippet/diagram/pagesettings/es5BGImage-cs1" %}
-## Page orientation
+## Page Orientation
-There are two types of page orientations:
+The diagram supports two page orientations:
-- Landscape
-- Portrait
+- **Landscape**: Wider than tall (default orientation).
+- **Portrait**: Taller than wide.
-Depending on the orientation selected, the width and height properties are adjusted accordingly. By default, the orientation is set to 'Landscape'. In the following example, the height and width properties of pageSettings are swapped when setting the orientation to 'Portrait'.
+When the orientation changes, the diagram automatically swaps the width and height values to maintain the specified page dimensions. For example, if a page is configured with width: 800 and height: 600 in landscape mode, switching to portrait orientation will result in width: 600 and height: 800.
+
+The following example demonstrates how orientation affects page dimensions by switching from the default landscape to portrait mode.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -72,9 +74,9 @@ Depending on the orientation selected, the width and height properties are adjus
{% previewsample "page.domainurl/code-snippet/diagram/pagesettings/es5pagesettings-cs2" %}
-## Multiple page and page breaks
+## Multiple Page and Page Breaks
-When multiple pages are enabled, the page size dynamically adjusts in multiples of the specified width and height, ensuring the entire diagram fits within the page boundaries. Page breaks serve as visual guides indicating how pages are split.
+The diagram can extend across multiple pages when the content exceeds the defined page boundaries. When multiple pages are enabled, the total canvas size automatically expands in increments of the specified page width and height to accommodate all diagram elements. Page breaks provide visual indicators showing where one page ends and another begins, which is particularly useful for print layout planning.
The [`multiplePage`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pageSettingsModel/#multiplepage) and [`showPageBreak`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pageSettingsModel/#showpagebreaks) properties in page settings control the ability to enable multiple pages and display page break lines, respectively.
@@ -91,18 +93,19 @@ The [`multiplePage`](https://helpej2.syncfusion.com/react/documentation/api/diag
The color of the page break lines can be customized by overriding the styles of the .e-diagram-page-break class. For more details refer to [`CSS customization`](https://ej2.syncfusion.com/react/documentation/diagram/style#customizing-the-page-breaks)
-## Boundary constraints
+## Boundary Constraints
+
+The appearance of page break lines can be customized by overriding the styles of the .e-diagram-page-break CSS class. For detailed styling options, refer to the [`boundaryConstraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/boundaryConstraints/) property in page settings.
-The diagram supports restricting or customizing the interactive region where elements cannot be dragged, resized, or rotated. You can achieve this using the [`boundaryConstraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/boundaryConstraints/) property in page settings.
+The three types of boundary constraints are:
-There are three types of boundary constraints. They are:
-- Infinity
-- Diagram
-- Page
+- **Infinity**: Elements can be moved without any boundary restrictions.
+- **Diagram**: Elements are constrained within the overall diagram area.
+- **Page**: Elements are restricted to the defined page boundaries.
-To explore these constraints further, refer to [`Boundary Constraints`](https://ej2.syncfusion.com/react/documentation/diagram/constraints#boundary-constraints).
+For detailed information about each constraint type and their behavior, refer to the [`Boundary Constraints`](https://ej2.syncfusion.com/react/documentation/diagram/constraints#boundary-constraints).
-Below is an example illustrating how to define boundary constraints within the diagram:
+The following example shows how to configure boundary constraints to restrict element movement within specific boundaries.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -115,11 +118,11 @@ Below is an example illustrating how to define boundary constraints within the d
{% previewsample "page.domainurl/code-snippet/diagram/pagesettings/es5boundaryconstraints-cs1" %}
-## Fit options
+## Fit Options
The [`fitOptions`](https://helpej2.syncfusion.com/react/documentation/api/diagram/fitOptionsModel/) in page settings control how diagram content is fitted within the diagram page. The [`canFit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/fitOptionsModel/#canfit) property within fitOptions centers the content within the viewport during diagram rendering. Additionally, the [`region`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramRegions/) property specifies whether to fit the page or the content to the center of the viewport. Choosing CustomBounds for the [`region`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramRegions/) allows fitting custom bounds within the diagram by defining them in the [`customBounds`](https://helpej2.syncfusion.com/react/documentation/api/diagram/fitOptionsModel/#custombounds) property of fitOptions. The [`canZoomIn`](https://helpej2.syncfusion.com/react/documentation/api/diagram/fitOptionsModel/#canzoomin) property enables zooming in to fit smaller content within the viewport. Additionally, the [`margin`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/) property defines the space around the fitted content within the viewport, while the [`mode`](https://helpej2.syncfusion.com/react/documentation/api/diagram/fitModes/) property sets the fitting mode, typically defaulting to 'Page' but also offering options like 'Width' and 'Height' for specific dimension constraints.
-The following example demonstrates how fitOptions are utilized in diagram page settings.
+The following example demonstrates the configuration and usage of fit options for automatic content positioning.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/palette-customization.md b/ej2-react/diagram/palette-customization.md
index ab6e7a76c..4f223f669 100644
--- a/ej2-react/diagram/palette-customization.md
+++ b/ej2-react/diagram/palette-customization.md
@@ -1,22 +1,21 @@
---
layout: post
-title: Palette customization in EJ2 React Diagram component | Syncfusion®
-description: Learn here how to customize symbol palette in React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Symbol Palette customization in EJ2 React Diagram Component | Syncfusion®
+description: Learn here all about Symbol palette customization in React Diagram Component of Syncfusion Essential® JS 2 and more.
platform: ej2-react
control: Symbol palette
documentation: ug
domainurl: ##DomainURL##
---
+# Symbol Palette customization in React Diagram Component
-# Symbol Palette customization in React Diagram component
+## Customize the Palette Header
-## Customize the palette header
-
-Palettes can be annotated with its header texts.
+The header of a symbol palette serves as a label that identifies the category or group of symbols it contains. It helps users quickly locate and understand the purpose of each palette.
The [`title`](https://ej2.syncfusion.com/react/documentation/api/diagram/paletteModel/#title) property displayed as the header text of palette.
-The [`expanded`](https://ej2.syncfusion.com/react/documentation/api/diagram/paletteModel/#expanded) property of palette allows to expand/collapse its palette items.
+The [`expanded`](https://ej2.syncfusion.com/react/documentation/api/diagram/paletteModel/#expanded) property of the palette allows users to expand or collapse its palette items.
The [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/paletteModel/#height) property of palette sets the height of the palette / symbol group.
@@ -37,7 +36,7 @@ The following code example illustrates how to customize palette headers.
## Animation
-The expand and collapse operation of symbol palette can be animated by utilizing the [`enableAnimation`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#enableanimation) property of symbol palette. The following example demonstrates, how to enable and disable animation for symbol palette.
+The expand and collapse operations of the symbol palette can be animated by utilizing the [`enableAnimation`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#enableanimation) property of the symbol palette. The following example demonstrates how to enable and disable animation for the symbol palette.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -50,9 +49,8 @@ The expand and collapse operation of symbol palette can be animated by utilizing
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/custompalette/palette-animate" %}
-## Description for symbols
-
-The [`description`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/) property defines the descriptive text that appears beneath each symbol in the palette. This text provides additional information about the symbol's purpose or usage within the diagramming context. The description can be dynamically retrieved and defined using the [`getSymbolInfo`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#getsymbolinfo/) property, allowing information to assist users in understanding the function or meaning of each symbol.
+## Description for Symbols
+The [`description`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/) property defines the descriptive text that appears beneath each symbol in the palette. This text provides additional information about the symbol's purpose or usage within the diagramming context. The description can be dynamically retrieved and defined using the [`getSymbolInfo`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#getsymbolinfo) property, allowing information to assist users in understanding the function or meaning of each symbol.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -65,11 +63,9 @@ The [`description`](https://ej2.syncfusion.com/react/documentation/api/diagram/s
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/custompalette/symbol-desc" %}
-### Text wrapping and text overflow
-
-The descriptive text that appears beneath each symbol can vary in length. In cases where the text might overlap neighboring symbols in the palette, text wrapping is employed. Text wrapping is controlled using the symbolInfo's [`description`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#symboldescription/) property [`wrap`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#wrap/) , which supports three modes: `Wrap`, `NoWrap`, `WrapWithOverflow`. By default, text wrapping is set to '`Wrap`'.
-
-Additionally, to handle overflowing text, the [`overflow`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#overflow/) property can be used. By default, textOverflow is set to '`Ellipsis`', which truncates overflowing text with an ellipsis (...).
+### Text wrapping and Text Overflow
+The descriptive text that appears beneath each symbol can vary in length. In cases where the text might overlap neighboring symbols in the palette, text wrapping is employed. Text wrapping is controlled using the symbolInfo's [`description`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#symboldescription) property [`wrap`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#wrap) , which supports three modes: `Wrap`, `NoWrap`, `WrapWithOverflow`. By default, text wrapping is set to '`Wrap`'.
+Additionally, to handle overflowing text, the [`overflow`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#overflow) property can be used. By default, textOverflow is set to '`Ellipsis`', which truncates overflowing text with an ellipsis (...).
The following example demonstrates how text wrapping and text overflow are applied based on the symbol ID:
@@ -84,9 +80,8 @@ The following example demonstrates how text wrapping and text overflow are appli
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/custompalette/symbol-textWrp" %}
-### Appearance of symbol description
-
-The appearance of a symbol description in the palette can be customized by changing its [`color`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#color/) , [`fill`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#fill/), [`fontSize`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#fontsize/) , [`fontFamily`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#fontfamily/), [`bold`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#bold/) [`italic`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#italic/), [`textDecoration`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#textdecoration/) and [`margin`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#margin/)
+### Appearance of Symbol Description
+The appearance of a symbol description in the palette can be customized by changing its [`color`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#color) , [`fill`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#fill), [`fontSize`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#fontsize) , [`fontFamily`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#fontfamily), [`bold`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#bold) [`italic`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#italic), [`textDecoration`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#textdecoration) and [`margin`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolDescription/#margin)
The following code example shows how to customize the symbol description.
@@ -101,11 +96,9 @@ The following code example shows how to customize the symbol description.
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/custompalette/symbol-text" %}
-## Symbol size and symbol margin
-
-The size of the individual symbol can be customized. The [`symbolWidth`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#symbolwidth/) and [`symbolHeight`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#symbolheight/) properties enables you to define the size of the symbols.
-
-The [`symbolMargin`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPaletteModel/#symbolmargin/) property is used to create the space around elements, outside of any defined borders. By setting the symbol margin with specific values for left, right, top, and bottom, you can create consistent spacing on all sides around the shape.
+## Symbol Size and Symbol Margin
+The size of individual symbols can be customized. The [`symbolWidth`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#symbolwidth) and [`symbolHeight`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#symbolheight) properties enables you to define the size of the symbols.
+The [`symbolMargin`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPaletteModel/#symbolmargin) property is used to create space around elements, outside of any defined borders. By setting the symbol margin with specific values for left, right, top, and bottom, you can create consistent spacing on all sides around the shape.
The following code example illustrates how to set symbol size and symbol margin for the symbol palette.
@@ -120,10 +113,10 @@ The following code example illustrates how to set symbol size and symbol margin
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/custompalette/size-cs1" %}
-## Symbol preview
+## Symbol Preview
The symbol preview size of the palette items can be customized using [`symbolPreview`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPreview) property of symbol palette.
-The [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPreview#width-number/) and [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPreview#height-number/) properties allow you to define the preview size for all the symbol palette items. The [`offset`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPreview#offset-PointModel/) property specifies the position of the dragging helper relative to the mouse cursor.
+The [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPreview#width-number) and [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPreview#height-number) properties allow you to define the preview size for all the symbol palette items. The [`offset`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPreview#offset-PointModel) property specifies the position of the dragging helper relative to the mouse cursor.
The following code example illustrates how to change the preview size of a palette item.
@@ -138,9 +131,8 @@ The following code example illustrates how to change the preview size of a palet
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/custompalette/symbol-preview" %}
-## Symbol drag size
-
-The [`symbolDragSize`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPaletteModel/#symboldragsize) property sets the dimensions (height and width) of a shape while it is being dragged from the palette to the diagram canvas. The following code illustrates how to set `symbolDragSize` for the symbol palette.
+## Symbol Drag Size
+The [`symbolDragSize`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPaletteModel/#symboldragsize) property sets the dimensions (height and width) of a shape while it is being dragged from the palette to the diagram canvas. This differs from the preview size, which only affects how symbols appear in the palette itself. The following code illustrates how to set `symbolDragSize` for the symbol palette.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -157,7 +149,7 @@ N> If the size of the symbol is not defined, the default size will be determined
## Expand Mode
-You can customize whether to expand all the palettes of symbol palette at a time or to expand only one palette at a time. This customization can be done using the [`expandMode`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#expandmode) property of symbol palette.
+The [`expandMode`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#expandmode) property of the symbol palette allows you to customize whether to expand all palettes simultaneously or to expand only one palette at a time.
The following example demonstrates how to set the `expandMode` property to control the expansion behavior of the palettes:
@@ -172,9 +164,8 @@ The following example demonstrates how to set the `expandMode` property to contr
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/custompalette/expandMode" %}
-### Restrict expand/collapse of the palette
-
-The symbol palette panel can be restricted from expanding. When we click on the expand icon of the palette, the [paletteExpanding](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPaletteModel/#paletteexpanding) event is triggered. In this event, we can determine whether the palette's panel should be expanded or collapsed by utilizing the `cancel` argument of the event. By default, the panel is expanded. This restriction can be applied to each palette in the symbol palette as desired.
+### Restrict Expand/Collapse of the Palette
+The symbol palette panel can be restricted from expanding. When the expand icon of the palette is clicked, the [paletteExpanding](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolPaletteModel/#paletteexpanding) event is triggered. In this event, we can determine whether the palette's panel should be expanded or collapsed by utilizing the **cancel** argument of the event. By default, the panel is expanded. This restriction can be applied to each palette in the symbol palette as desired.
In the following code example, the basic shapes palette is restricted from expanding, and the flow shapes palette is restricted from collapsing, whereas the swimlane shapes palette can be expanded or collapsed:
@@ -189,22 +180,18 @@ In the following code example, the basic shapes palette is restricted from expan
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/custompalette/restrict-expand" %}
-## Tooltip for symbols in symbol palette
-
-The Symbol palette supports displaying tooltips when mouse hovers over the symbols. You can customize the tooltip for each symbol in the symbol palette.
-
-### Default tooltip for symbols
+## Tooltip for Symbols in Symbol Palette
+The symbol palette supports displaying tooltips when the mouse hovers over symbols. You can customize the tooltip for each symbol in the symbol palette.
+### Default Tooltip for Symbols
When hovering over symbols in the symbol palette, the default tooltip displays the symbol's ID.
Refer to the image below for an illustration of the tooltip behavior in the symbol palette.

-### Custom tooltip for symbols
-
-To customize the tooltips for symbols in the symbol palette, assign a custom tooltip to the [`content`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramTooltipModel/#content) property of ['tooltip'](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeModel/#tooltip) for each symbol. Once you define the custom tooltip, enable the [`Tooltip`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeConstraints/) constraints for each symbol, ensuring that the tooltips are displayed when users hover over them.
-
-The code provided below demonstrates how to define tooltip content to symbols within a symbol palette.
+### Custom Tooltip for Symbols
+To customize tooltips for symbols in the symbol palette, assign a custom tooltip to the [`content`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramTooltipModel/#content) property of ['tooltip'](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeModel/#tooltip) for each symbol. Once you define the custom tooltip, enable the [`Tooltip`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeConstraints/) constraints for each symbol, ensuring that the tooltips are displayed when users hover over them.
+The code provided below demonstrates how to define tooltip content for symbols within a symbol palette.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -243,13 +230,11 @@ When a custom tooltip is defined for a symbol, it will be displayed for both the
However, to provide distinct tooltips for symbols in the palette and dropped nodes, capture the dragEnter event and assign specific tooltips dynamically.
-When a symbol is dragged from the symbol palette and enters the diagram canvas, the [`DragEnter`](https://ej2.syncfusion.com/react/documentation/api/diagram#dragenter/), event is fired, accompanied by an argument of type [`IDragEnterEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/iDragEnterEventArgs/). event is triggered. Within this event, you can define a new tooltip for the dropped node. By assigning custom tooltip content to the Tooltip property of the node, you can provide a distinct tooltip that is specific to the dropped node.
+When a symbol is dragged from the symbol palette onto the diagram canvas, the [`DragEnter`](https://ej2.syncfusion.com/react/documentation/api/diagram#dragenter), event is triggered. This event provides an argument of type [`IDragEnterEventArgs`](https://ej2.syncfusion.com/react/documentation/api/diagram/iDragEnterEventArgs). Within this event, you can define a custom tooltip for the dropped node by assigning content to its tooltip property, allowing you to display context-specific information.
The following image illustrates the differentiation of tooltips displayed in the Symbol Palette and the Diagram.
-

-
-The following code snippet will demonstrate how to define two different tooltip for symbol in the symbol palette and dropped node in the diagram canvas.
+The following code snippet demonstrates how to define two different tooltips for symbols in the symbol palette and dropped nodes in the diagram canvas.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -264,8 +249,7 @@ The following code snippet will demonstrate how to define two different tooltip
## Localization
-To localize the symbol palette search box, we need to define the [`locale`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#locale/) property of the symbol palette with our preferred culture. In the example below, we use **'de-DE**', which is the locale code for German as used in Germany.
-
+To localize the symbol palette search box, we need to define the [`locale`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#locale) property of the symbol palette with the preferred culture. In the example below, **'de-DE'** is used, which is the locale code for German as used in Germany.
The following code shows how to localize symbol palette.
{% tabs %}
@@ -279,9 +263,8 @@ The following code shows how to localize symbol palette.
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/custompalette/locale" %}
-## Restrict symbol dragging from palette
-
-You can restrict the symbols getting dragged from the symbol palette by setting the [`allowDrag`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#allowdrag/) property of symbol palette as false. By default, the allowDrag is set as **true**.
+## Restrict Symbol Dragging from Palette
+You can restrict the symbols getting dragged from the symbol palette by setting the [`allowDrag`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#allowdrag) property of symbol palette as **false**. By default, the allowDrag is set as **true**.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -294,9 +277,8 @@ You can restrict the symbols getting dragged from the symbol palette by setting
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/custompalette/restrict-drag" %}
-## Search symbol
-
-The diagram provides support for enabling the search option in the palette. The [`enableSearch`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#enablesearch/) property of the palette is used to show or hide the search textbox in the palette. You can search for symbols in the palette by entering the symbol ID (e.g., “rectangle”) and search keywords into the search text box. The symbols are retrieved by matching the value of the ID property with the string entered in the search textbox.
+## Search Symbol
+The diagram provides support for enabling the search option in the palette. The [`enableSearch`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#enablesearch) property of the palette is used to show or hide the search textbox in the palette. You can search for symbols in the palette by entering the symbol ID (e.g., “rectangle”) and search keywords into the search text box. The symbols are retrieved by matching the value of the ID property with the string entered in the search textbox.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -309,11 +291,9 @@ The diagram provides support for enabling the search option in the palette. The
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/custompalette/symbol-search" %}
-## Ignore symbols on search
-
-The [`ignoreSymbolsOnSearch`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#ignoresymbolsonsearch/) property allows you to specify which symbols should be excluded from search results within the symbol palette. By setting this property, you can control the visibility of specific symbols during a search operation. This feature is useful for hiding certain symbols that you don't want to be shown via search.
-
-In the following example, we ignored the symbol with the ID of 'plus', so it will not appear in the search results.
+## Ignore Symbols on Search
+The [`ignoreSymbolsOnSearch`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#ignoresymbolsonsearch) property allows you to specify which symbols should be excluded from search results within the symbol palette. By setting this property, you can control the visibility of specific symbols during a search operation. This feature is useful for hiding certain symbols that should not be shown through search functionality.
+In the following example, the symbol with the ID 'plus' is ignored, so it will not appear in search results.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -326,9 +306,8 @@ In the following example, we ignored the symbol with the ID of 'plus', so it wil
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/custompalette/symbol-search-ig" %}
-## Filter search
-
-You can filter the search results based on your specific requirements. To achieve this, customize the [`filterSymbols`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#filtersymbols/) method of the symbol palette according to your needs. In the following example, we filter the results to display only flow shapes in the search palette.
+## Filter Search
+You can filter the search results based on your specific requirements. To achieve this, customize the [`filterSymbols`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#filtersymbols) method of the symbol palette according to your needs. In the following example, the results are filtered to display only flow shapes in the search palette.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -341,8 +320,8 @@ You can filter the search results based on your specific requirements. To achiev
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/custompalette/symbol-filter" %}
-N> The diagram provides support to cancel the drag and drop operation from the symbol palette to the diagram when the ESC key is pressed
+N> The diagram provides support to cancel the drag and drop operation from the symbol palette to the diagram when the ESC key is pressed.
## See Also
-* [How to add the symbol to the diagram](./nodes)
\ No newline at end of file
+* [How to add the symbol to the diagram.](./nodes)
\ No newline at end of file
diff --git a/ej2-react/diagram/palette-events.md b/ej2-react/diagram/palette-events.md
index 5c8a1a0dc..5582dbeaa 100644
--- a/ej2-react/diagram/palette-events.md
+++ b/ej2-react/diagram/palette-events.md
@@ -1,20 +1,20 @@
---
layout: post
-title: Symbol Palette Events in EJ2 React Diagram component | Syncfusion®
-description: Learn here all about Symbol palette in React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Symbol Palette Events in EJ2 React Diagram Component | Syncfusion®
+description: Learn here all about Symbol palette events in Syncfusion® React Diagram Component including drag-drop events, palette expansion, and selection change events.
platform: ej2-react
control: Symbol palette
documentation: ug
domainurl: ##DomainURL##
---
-# Symbol Palette Events in EJ2 React Diagram component
+# Symbol Palette Events in EJ2 React Diagram Component
-There are some events which will get triggered while interacting with the symbol palette. They are explained below.
+The Symbol Palette component provides several events that trigger during user interactions such as dragging symbols, expanding palettes, and changing selections. These events enable developers to customize behavior, provide visual feedback, and implement custom logic during symbol palette operations.
-## DragEnter event
+## DragEnter Event
-[`DragEnter`](https://ej2.syncfusion.com/react/documentation/api/diagram/iDragEnterEventArgs) event triggers when the shape enters the diagram surface while dragging it from symbol palette. You can customize the style of the dragged shape using this event. This allows for dynamic styling changes based on the diagram's context.
+The [`DragEnter`](https://ej2.syncfusion.com/react/documentation/api/diagram/iDragEnterEventArgs) event triggers when a symbol enters the diagram surface while being dragged from the symbol palette. This event allows developers to customize the appearance of the dragged symbol or validate drop targets dynamically based on the diagram's current state.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -27,9 +27,9 @@ There are some events which will get triggered while interacting with the symbol
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/events/drag-enter" %}
-## DragLeave event
+## DragLeave Event
-[`DragLeave`](https://ej2.syncfusion.com/react/documentation/api/diagram/iDragLeaveEventArgs) event occurs when a shape leaves the diagram surface after being dragged inside but not dropped. This can be useful for resetting styles or handling any clean-up tasks when a shape is not intended to be placed on the diagram.
+The [`DragLeave`](https://ej2.syncfusion.com/react/documentation/api/diagram/iDragLeaveEventArgs) event occurs when a dragged symbol leaves the diagram surface without being dropped. This event is particularly useful for cleaning up temporary visual changes applied during the drag operation or resetting any modified states.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -42,9 +42,9 @@ There are some events which will get triggered while interacting with the symbol
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/events/drag-leave" %}
-## DragOver event
+## DragOver Event
-[`DragOver`](https://ej2.syncfusion.com/react/documentation/api/diagram/iDragOverEventArgs) event triggered when a shape is dragged over diagram while being moved from the symbol palette. This event can be used to provide visual feedback or to determine if the current drop target is valid.
+The [`DragOver`](https://ej2.syncfusion.com/react/documentation/api/diagram/iDragOverEventArgs) event triggers continuously while a symbol is being dragged over the diagram surface. This event provides real-time feedback during drag operations and enables developers to implement dynamic drop validation.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -57,9 +57,9 @@ There are some events which will get triggered while interacting with the symbol
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/events/drag-over" %}
-## Drop event
+## Drop Event
-[`Drop`](https://ej2.syncfusion.com/react/documentation/api/diagram/iDropEventArgs/) event triggered when a shape is dropped onto the diagram surface. This event is useful for customizing the shape's appearance and properties after it is dropped.
+The [`Drop`](https://ej2.syncfusion.com/react/documentation/api/diagram/iDropEventArgs/) event triggers when a symbol is successfully dropped onto the diagram surface. This event serves as the final step in the drag-and-drop process and provides access to both the dropped symbol and the target location.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -72,9 +72,9 @@ There are some events which will get triggered while interacting with the symbol
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/events/drop" %}
-## PaletteExpanding event
+## PaletteExpanding Event
-[`PaletteExpanding`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPaletteExpandArgs/) event triggered when the palette expanded / collapsed.
+The [`PaletteExpanding`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPaletteExpandArgs/) event triggers when a palette group is expanded or collapsed within the symbol palette. This event enables developers to control palette expansion behavior and implement custom logic based on palette state changes.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -87,9 +87,9 @@ There are some events which will get triggered while interacting with the symbol
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/events/palette-expand" %}
-## PaletteSelectionChange event
+## PaletteSelectionChange Event
-[`PaletteSelectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPaletteSelectionChangeArgs/) event triggered after the selection changes in the symbol palette. This event can be used to enable/disable functionality based on the selected symbol.
+The [`PaletteSelectionChange`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPaletteSelectionChangeArgs/) event triggers when the selection changes within the symbol palette. This event provides information about both the previously selected and newly selected symbols, enabling developers to respond to selection changes appropriately.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/phase.md b/ej2-react/diagram/phase.md
index 58a47efab..0c438c44e 100644
--- a/ej2-react/diagram/phase.md
+++ b/ej2-react/diagram/phase.md
@@ -1,16 +1,18 @@
---
layout: post
-title: Phase in React Diagram component | Syncfusion®
-description: Learn here all about Swim lane in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Phase in React Diagram Component | Syncfusion®
+description: Learn here all about Swim lane in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Phase
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-## Phase
+# Phase in React Diagram Component
-Phase are the subprocess which will split each lanes as horizontally or vertically based on the swimlane orientation. We can add multiple number of [`Phase`](https://ej2.syncfusion.com/react/documentation/api/diagram/phaseModel)to swimlane.
+## Overview
+
+Phases are subprocesses that split each lane horizontally or vertically based on the swimlane orientation. Phases help organize workflow stages within lanes, making it easier to visualize process steps and milestones. Multiple [`Phase`](https://ej2.syncfusion.com/react/documentation/api/diagram/phaseModel)objects can be added to a swimlane to represent different stages of a process.
The following code example illustrates how to create phase.
@@ -25,9 +27,11 @@ The following code example illustrates how to create phase.
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5Phase-cs1" %}
-### Dynamically add/remove phase to Lane
+### Dynamically Add and Remove Phases from Lanes
+
+Phases can be added at runtime using the [`addPhases`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addphases) method and removed using the [`removePhase`](https://ej2.syncfusion.com/react/documentation/api/diagram/#removephase) method. This dynamic functionality allows for flexible workflow management as process requirements change.
-You can add a phase at runtime by using [`addPhases`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addphases) method and remove phase by using [`removePhase`](https://ej2.syncfusion.com/react/documentation/api/diagram/#removephase) method. The following code example illustrates how to add and remove phase at run time.
+The following code example illustrates how to add and remove phases at runtime.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -40,12 +44,14 @@ You can add a phase at runtime by using [`addPhases`](https://ej2.syncfusion.com
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5PhaseCustomize-cs3" %}
-### Customizing phase
+### Customizing Phase Appearance and Properties
+
+Phase appearance and behavior can be customized through several properties:
-* The length of the region can be set by using the [`offset`](https://ej2.syncfusion.com/react/documentation/api/diagram/phaseModel#offset) property of the phase.
-* Every phase region can be textually described with the [`header`](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel) property of the phase.
-* You can increase the height of phase by using [`phaseSize`](https://ej2.syncfusion.com/react/documentation/api/diagram/swimLaneModel#phaseSize) property of swimlane.
-* We can provide additional information to the phase by using the [`addInfo`](https://ej2.syncfusion.com/react/documentation/api/diagram/phaseModel#addInfo) property of the phase.
+* The length of each region can be controlled using the[`offset`](https://ej2.syncfusion.com/react/documentation/api/diagram/phaseModel#offset) property of the phase.
+* Each phase region can include descriptive text through the[`header`](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel) property of the phase.
+* The height of phases can be increased using the [`phaseSize`](https://ej2.syncfusion.com/react/documentation/api/diagram/swimLaneModel#phaseSize) property of swimlane.
+* Additional information can be stored with phases using the [`addInfo`](https://ej2.syncfusion.com/react/documentation/api/diagram/phaseModel#addInfo) property of the phase.
The following code example illustrates how to customize the phase in swimlane.
@@ -60,9 +66,9 @@ The following code example illustrates how to customize the phase in swimlane.
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5PhaseCustomize-cs4" %}
-#### Dynamic customization of phase
+#### Dynamic Customization of Phases
-You can customize the phase style and text properties dynamically. The following code illustrates how to dynamically customize the phase.
+Phase style and text properties can be customized dynamically during runtime. This capability enables responsive design adjustments based on user interactions or changing data requirements.
The following code example illustrates how to customize the phase at runtime.
@@ -77,21 +83,23 @@ The following code example illustrates how to customize the phase at runtime.
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5PhaseCustomize-cs5" %}
-### Phase interaction
+### Phase Interaction Capabilities
-#### Resizing
+#### Resizing Phases
-* The phase can be resized by using its selector.
-* You must select the phase header to enable the phase selection.
-* Once the phase can be resized, the lane size will be updated automatically.
+* Phases can be resized using their selection handles.
+* The phase header must be selected first to enable phase selection.
+* When a phase is resized, the associated lane size updates automatically to maintain layout consistency.
-#### Resizing helper
+#### Resizing Helper Functionality
-* The special resize selector will be used to resize the phase.
-* The resize cursor will be available on the left and bottom direction for horizontal, and the top and bottom direction for vertical swimlane.
+* A specialized resize selector is used for phase resizing operations.
+* The resize cursor appears in different directions based on swimlane orientation: left and bottom directions for horizontal swimlanes, and top and bottom directions for vertical swimlanes.
-#### Phase header editing
+#### Phase Header Editing
-Diagram provides the support to edit phase headers at runtime. We achieve the header editing by double click event. Double clicking the header label will enables the editing of that. The following image illustrates how to edit the swimlane header.The following image illustrates how to edit the phase header. 
+The diagram component provides support for editing phase headers at runtime through double-click interaction. Double-clicking the header label enables inline editing functionality, allowing users to modify phase titles directly within the diagram.
+The following image illustrates the phase header editing process:
+
\ No newline at end of file
diff --git a/ej2-react/diagram/ports-appearance.md b/ej2-react/diagram/ports-appearance.md
index f2bf25030..776d97d17 100644
--- a/ej2-react/diagram/ports-appearance.md
+++ b/ej2-react/diagram/ports-appearance.md
@@ -1,19 +1,20 @@
---
layout: post
-title: Ports appearance in React Diagram component | Syncfusion®
-description: Learn here all about Ports in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Ports appearance in React Diagram Component | Syncfusion®
+description: Learn how to customize port appearance, visibility, shapes, and constraints in Syncfusion® React Diagram Component for enhanced visual design.
control: Ports
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
+# Customize Port Appearance in React Diagram Component
-## Appearance
+## Overview
-The appearance of ports can be customized by using [`strokeColor`](https://ej2.syncfusion.com/react/documentation/api/diagram/shapeStyleModel/#strokecolor), [`strokeWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/shapeStyleModel/#strokewidth),[`fill`](https://ej2.syncfusion.com/react/documentation/api/diagram/shapeStyleModel/#fill) and [`opacity`](https://ej2.syncfusion.com/react/documentation/api/diagram/shapeStyleModel/#opacity) properties of the port. Customize the port size by using the [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/#height) properties of port. The ports [`visibility`](https://ej2.syncfusion.com/react/documentation/api/diagram/portvisibility/) property allows you to define, when the port should be visible.
+Ports serve as connection points on diagram nodes where connectors can be attached. The appearance of ports can be customized using the[`strokeColor`](https://ej2.syncfusion.com/react/documentation/api/diagram/shapeStyleModel/#strokecolor), [`strokeWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/shapeStyleModel/#strokewidth),[`fill`](https://ej2.syncfusion.com/react/documentation/api/diagram/shapeStyleModel/#fill) and [`opacity`](https://ej2.syncfusion.com/react/documentation/api/diagram/shapeStyleModel/#opacity) properties of the port. Customize the port size by using the [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/#height) properties of port. The ports [`visibility`](https://ej2.syncfusion.com/react/documentation/api/diagram/portvisibility/) property allows you to define, when the port should be visible.
-For more information about port visibility refer [`Port Visibility`](#port-visibility)
+For more information about port visibility refer [`PortVisibility`](#port-visibility)
The following code illustrates how to change the appearance of port.
@@ -28,9 +29,9 @@ The following code illustrates how to change the appearance of port.
{% previewsample "page.domainurl/code-snippet/diagram/ports/ports-cs5" %}
-### Change appearance of port at runtime
+### Change Appearance of Port at Runtime
-The appearance of port can be changed at runtime by customizing the style of port.The following code illustrates how to change the appearance of port at runtime.
+The appearance of port can be changed at runtime by customizing the style properties of the port. This is useful when you need to provide visual feedback based on user interactions or application state changes. The following code illustrates how to change the appearance of port at runtime.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -43,9 +44,9 @@ The appearance of port can be changed at runtime by customizing the style of por
{% previewsample "page.domainurl/code-snippet/diagram/ports/ports-cs6" %}
-## Port visibility
+## Port Visibility
-The visibility of the ports is determined by the [`visibility`](https://ej2.syncfusion.com/react/documentation/api/diagram/portvisibility/) property of port using the [`PortVisibility`](https://ej2.syncfusion.com/react/documentation/api/diagram/portVisibility/) enum, This enum includes properties such as `Connect`, `Hidden`, `Hover`, and `Visible`. By default, the port visibility is set to **Hidden**.
+The visibility of the ports is determined by the [`visibility`](https://ej2.syncfusion.com/react/documentation/api/diagram/portvisibility/) property of port using the [`PortVisibility`](https://ej2.syncfusion.com/react/documentation/api/diagram/portVisibility/) enum, This enum includes properties such as **Connect**, **Hidden**, **Hover**, and **Visible**. By default, the port visibility is set to **Hidden**.
| Property | Definition |
|----|----|
@@ -54,23 +55,23 @@ The visibility of the ports is determined by the [`visibility`](https://ej2.sync
| Connect | The port becomes visible when you hover the connector thumb over the DiagramElement where the port resides. |
| Visible | Port is always visible for the DiagramElement. |
-## Port shape
+## Port Shape
-The shape of port can be changed by using its shape property. To explore the different types of port shapes, refer to [`Port Shapes`](https://ej2.syncfusion.com/react/documentation/api/diagram/portshapes/). By default the port shape is `Square`.
+The shape of port can be changed by using its shape property. To explore the different types of port shapes, refer to [`Port Shapes`](https://ej2.syncfusion.com/react/documentation/api/diagram/portshapes/). By default the port shape is **Square**.Different shapes help distinguish between different types of connections or data flow directions.
-### Types of port shapes
+### Types of Port Shapes
-We have provided some basic built-in `PortShapes` for the port. Find the shapes as follows.
+The following basic built-in `PortShapes` are available for ports:
* Circle
* Custom
* Square
* X
-### Customize the port’s shape
+### Customize the Port’s Shape
-Custom shape support has been provided for port. You can able to add the custom path data instead of build-in shapes.
-If you need to render a custom shape, then you can set shape as `Custom` and define path using [`pathData`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/#pathdata) property of port.
+Custom shape support has been provided for port. You can able to add the custom path data instead of built-in shapes when you need specific visual indicators that match your application's design requirements or represent particular data types.
+If you need to render a custom shape, then you can set shape as **Custom** and define path using [`pathData`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/#pathdata) property of port.
The following code illustrates how to set custom shape to the port.
@@ -88,7 +89,7 @@ If you need to render a custom shape, then you can set shape as `Custom` and def
## Constraints
-The constraints property allows to enable/disable certain behaviors of ports. For more information about port constraints, refer to [`Port Constraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/portconstraints/).
+The constraints property allows you to enable or disable certain behaviors of ports, providing fine-grained control over port functionality. For more information about port constraints, refer to [`PortConstraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/portconstraints/).
The PortConstraints may have multiple behaviors like listed below:
@@ -104,8 +105,8 @@ The PortConstraints may have multiple behaviors like listed below:
## See also
-* [How to interact with the ports](./ports-interaction)
+* [How to interact with the ports.](./ports-interaction)
-* [How to set the position of the port](./ports-positioning)
+* [How to set the position of the port.](./ports-positioning)
-* [How to create connector port](./ports-connector-port)
\ No newline at end of file
+* [How to create connector port.](./ports-connector-port)
\ No newline at end of file
diff --git a/ej2-react/diagram/ports-connector-port.md b/ej2-react/diagram/ports-connector-port.md
index 20728aa2c..fa695976e 100644
--- a/ej2-react/diagram/ports-connector-port.md
+++ b/ej2-react/diagram/ports-connector-port.md
@@ -1,16 +1,20 @@
---
layout: post
-title: Connector ports in React Diagram component | Syncfusion®
-description: Learn here all about Ports in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Connector ports in React Diagram Component | Syncfusion®
+description: Learn how to create connector ports, configure alignment and displacement, and establish port-to-port connections in Syncfusion® React Diagram Component.
control: Ports
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-## Create connector port
+# Using Connector Ports in React Diagram Component
-The creation of connector ports is similar to the creation of node ports. To create connector ports, you need to define a port collection and assign it to the connector's ports property.
+Connector ports serve as connection points along connectors, enabling other connectors to attach at specific locations rather than just the endpoints. This guide covers creating connector ports, configuring their alignment and displacement, and establishing port-to-port connections.
+
+## Create Connector Port
+
+Connector ports serve as connection points along connectors, enabling other connectors to attach at specific locations rather than just the endpoints. Creating connector ports follows the same pattern as node ports - define a port collection and assign it to the connector's [`ports`](https://ej2.syncfusion.com/react/documentation/api/diagram/connector/#ports) property.
The following code example shows how to create connector port.
@@ -26,11 +30,15 @@ The following code example shows how to create connector port.
{% previewsample "page.domainurl/code-snippet/diagram/ports/ports-con1"%}
-## Port alignment
+## Port Alignment
-The port can be aligned before, after, or at the center of the connector by utilizing the [`alignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/portAlignment/) property. By default, the port alignment is set to **center**.
+Control the position of ports along the connector using the [`alignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/portAlignment/) property. This property determines where the port appears relative to the connector's path:
-The following code example shows how to set alignment to the connector port.
+- **Before**: Positions the port at the source end of the connector.
+- **After**: Positions the port at the target end of the connector.
+- **Center**: Positions the port at the midpoint of the connector (default).
+
+The following code example shows how to set different alignment values for connector ports:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -45,11 +53,11 @@ The following code example shows how to set alignment to the connector port.
-## Port displacement
+## Port Displacement
-The connector port displacement allows users to adjust the position of ports relative to the connector. By setting displacement offsets, ports can be moved to precise locations along the connector.
+Fine-tune port positioning using the [`displacement`](https://ej2.syncfusion.com/react/documentation/api/diagram/point/) property, which applies offset values to move ports from their aligned position. Displacement works by shifting the port by specified x and y coordinates relative to the alignment point.
-The following code example shows how to set displacement to the connector port.
+The following code example demonstrates how to apply displacement to connector ports:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -65,12 +73,11 @@ The following code example shows how to set displacement to the connector port.
N> The displacement will work only if we set alignment as after or before.
-## Connector port connection
-
-To establish a connection between connectors, connector ports are utilized. For this connection, the `sourcePortID` or `targetPortID` should be set to the ID of the respective port on the connector.
+## Establish Port-to-Port Connections
-The following code example explains how to connect connector to the connector port.
+Connect one connector to another connector's port by specifying the port ID in the [`sourcePortID`](https://ej2.syncfusion.com/react/documentation/api/diagram/connector/#sourceportid) or [`targetPortID`](https://ej2.syncfusion.com/react/documentation/api/diagram/connector/#targetportid) property. This creates precise connection points along connector paths instead of connecting to endpoints.
+The following code example shows how to connect a connector to a connector port:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -85,8 +92,8 @@ The following code example explains how to connect connector to the connector po
## See also
-* [How to customize the ports](./ports-appearance)
+* [How to customize the ports.](./ports-appearance)
-* [How to set the position of the port](./ports-positioning)
+* [How to set the position of the port.](./ports-positioning)
-* [How to interact with the ports](./ports-interaction)
\ No newline at end of file
+* [How to interact with the ports.](./ports-interaction)
\ No newline at end of file
diff --git a/ej2-react/diagram/ports-interaction.md b/ej2-react/diagram/ports-interaction.md
index 047238c57..a4ffcf905 100644
--- a/ej2-react/diagram/ports-interaction.md
+++ b/ej2-react/diagram/ports-interaction.md
@@ -1,16 +1,20 @@
---
layout: post
-title: Ports interaction in React Diagram component | Syncfusion®
-description: Learn here all about Ports in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Ports interaction in React Diagram Component | Syncfusion®
+description: Learn about ports interaction in Syncfusion® React Diagram Component including drawing connectors, drag functionality, and events.
control: Ports
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-## Draw connector from port
+# Interactive Port Features in React Diagram Component
-The port can be used to create connector by enabling `Draw` constraints to the [`constraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/portconstraints/) property. By default, the connector segment type is set to **Orthogonal**.
+Ports in React Diagram components support various interactive features that enhance user workflow and diagram creation efficiency. This guide covers drawing connectors from ports, drag functionality, automatic port creation, tooltips, and event handling.
+
+## Draw Connector from Port
+
+Ports can serve as connection points for creating connectors dynamically. Enable the `Draw` constraint on the [`constraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/portconstraints/) property to allow users to draw connectors directly from ports. The default connector segment type is **Orthogonal**, providing structured, right-angled connections suitable for flowcharts and organizational diagrams.
The following code explains how to draw the connector by using the port constraints.
@@ -25,15 +29,13 @@ The following code explains how to draw the connector by using the port constrai
{% previewsample "page.domainurl/code-snippet/diagram/ports/ports-int1" %}
-### Draw different connector types from port
-
-You can change the default connector type while drawing the connector from the port by setting the specific connector type in connector defaults. This enables the drawing of various connector types from the port, including:
+### Draw Different Connector Types from Port
-* Straight
-* Bezier
-* Orthogonal
+The default connector type can be customized when drawing from ports by configuring connector defaults. This flexibility allows creation of various connector styles to match different diagram requirements:
-The following code explains how to draw different connectors by using the port constraints.
+* **Straight**: Direct linear connections for simple relationships.
+* **Bezier**: Curved connections for organic, flowing designs.
+* **Orthogonal**: Right-angled connections for structured layouts.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -46,9 +48,9 @@ The following code explains how to draw different connectors by using the port c
{% previewsample "page.domainurl/code-snippet/diagram/ports/ports-int2" %}
-## Port drag
+## Port Drag
-The port drag feature allows users to click and drag a port using the mouse. This functionality can be enabled by setting the port constraints to **"Drag"**.
+Port drag functionality enables users to reposition ports by clicking and dragging with the mouse. This feature enhances diagram flexibility by allowing dynamic port placement adjustments. Enable this capability by setting the port constraints to **Drag**.
The following code explains how to enable port drag.
@@ -65,9 +67,9 @@ The following code explains how to enable port drag.
## Automatic Port Creation
-The Diagram component allows you to dynamically create ports on nodes or connectors by clicking and dragging the mouse while holding the Control (Ctrl) key. This feature is disabled by default and can be enabled by using the `DiagramConstraints.AutomaticPortCreation` constraint.
+The Diagram component supports dynamic port creation through user interaction. Users can create ports on nodes or connectors by clicking and dragging while holding the Control (Ctrl) key. This feature is disabled by default and requires enabling the `DiagramConstraints.AutomaticPortCreation` constraint.
-You can also remove a port using the same Ctrl + Click interaction, but only if the port is not currently connected to any connector.
+Ports can also be removed using the same Ctrl + Click interaction, provided the port is not connected to any connector. This prevents accidental disconnection of active connections.
The following example shows how to enable automatic port creation:
@@ -82,9 +84,9 @@ The following example shows how to enable automatic port creation:
{% previewsample "page.domainurl/code-snippet/diagram/ports/automaticPortCreation" %}
-## Port tooltip
+## Port Tooltip
-The port tooltip feature allows a tooltip to be displayed when hovering over a port. This functionality can be enabled by setting the port constraints to **"Tooltip"**.
+Port tooltips provide contextual information when users hover over ports, improving usability and user guidance. Enable this feature by setting the port constraints to **Tooltip**.
The following code explains how to enable port tooltip.
@@ -101,7 +103,7 @@ The following code explains how to enable port tooltip.
## Events
-There are several events that can be triggered while interacting with ports. These events are listed in the table below.
+Port interactions trigger specific events that enable custom handling and application logic. These events provide hooks for implementing validation, logging, or custom behaviors during port operations.
| Event| Description|
|----|----|
@@ -123,12 +125,10 @@ The following example shows how to get these events in diagram.
{% previewsample "page.domainurl/code-snippet/diagram/ports/ports-int5" %}
-
-
## See also
-* [How to customize the ports](./ports-appearance)
+* [How to customize the ports.](./ports-appearance)
-* [How to set the position of the port](./ports-positioning)
+* [How to set the position of the port.](./ports-positioning)
-* [How to create connector port](./ports-connector-port)
+* [How to create connector port.](./ports-connector-port)
diff --git a/ej2-react/diagram/ports-positioning.md b/ej2-react/diagram/ports-positioning.md
index fc4a3758a..b5705f2ef 100644
--- a/ej2-react/diagram/ports-positioning.md
+++ b/ej2-react/diagram/ports-positioning.md
@@ -1,23 +1,26 @@
---
layout: post
-title: Ports positioning in React Diagram component | Syncfusion®
-description: Learn here all about Ports in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Ports positioning in React Diagram Component | Syncfusion®
+description: Learn how to position ports on nodes in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Ports
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
+# Port positioning in React Diagram Component
-# Positioning node's port
+The React Diagram component provides flexible options for positioning ports on nodes. Ports can be precisely positioned using offset coordinates, alignment properties, and margin values to create professional diagram layouts that meet specific design requirements.
-Diagram allows you to customize the position of the port efficiently. Port can be aligned relative to the node boundaries. It has Margin, Offset, Horizontal, and Vertical alignment settings.
+## Understanding Port Offset Positioning
-## Port offset
+The [`offset`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointModel/) property positions ports using fractional coordinates relative to the node boundaries. The coordinate system uses values from 0 to 1, where:
-The [`offset`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointModel/) property is used to align the ports based on fractions. 0 represents top/left corner, 1 represents bottom/right corner, and 0.5 represents half of width/height.
+- **0** represents the top edge (for Y-axis) or left edge (for X-axis).
+- **1** represents the bottom edge (for Y-axis) or right edge (for X-axis).
+- **0.5** represents the center point of the width or height.
-The following table shows the position of port within the shape.
+The following table demonstrates port positioning with different offset values:
| Offset values | Output |
| -------- | -------- |
@@ -31,9 +34,9 @@ The following table shows the position of port within the shape.
| (1,0.5) |  |
| (1,1) |  |
-## Horizontal and vertical alignment
+## Horizontal and Vertical Alignment Options
-The [`horizontalAlignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/horizontalAlignment/) property of the port is used to set how the port is horizontally aligned at the port position. The [`verticalAlignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/verticalAlignment/) property is used to set how the port is vertically aligned at the port position.
+The [`horizontalAlignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/horizontalAlignment/) and [`verticalAlignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/verticalAlignment/) properties provide fine-grained control over port positioning at the specified offset coordinates. These properties determine how the port aligns relative to its calculated position.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -47,7 +50,7 @@ The [`horizontalAlignment`](https://ej2.syncfusion.com/react/documentation/api/d
{% previewsample "page.domainurl/code-snippet/diagram/ports/ports-pos1" %}
-The following table shows all the possible alignments visually with offset (0, 0).
+The following table shows all possible alignment combinations when using offset (0, 0):
| Horizontal Alignment | Vertical Alignment | Output with Offset(0,0) |
| -------- | -------- | -------- |
@@ -63,9 +66,9 @@ The following table shows all the possible alignments visually with offset (0, 0
-## Margin for port
+## Adding Margin Spacing to Ports
-[`Margin`](https://ej2.syncfusion.com/react/documentation/api/diagram/marginModel/) is an absolute value used to add some blank space to any one of its four sides. The ports can be displaced with the margin property. The following code example explains how to align a port based on its offset and margin values.
+[`Margin`](https://ej2.syncfusion.com/react/documentation/api/diagram/marginModel/) property applies additional spacing around ports using absolute pixel values. Margin creates blank space on any or all four sides of the port, allowing for precise positioning adjustments beyond the basic offset and alignment settings.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -80,8 +83,8 @@ The following table shows all the possible alignments visually with offset (0, 0
## See also
-* [How to interact with the ports](./ports-interaction)
+* [How to interact with the ports.](./ports-interaction)
-* [How to customize the ports](./ports-appearance)
+* [How to customize the ports.](./ports-appearance)
-* [How to create connector port](./ports-connector-port)
\ No newline at end of file
+* [How to create connector port.](./ports-connector-port)
\ No newline at end of file
diff --git a/ej2-react/diagram/ports.md b/ej2-react/diagram/ports.md
index e458828c2..e4a7b3c92 100644
--- a/ej2-react/diagram/ports.md
+++ b/ej2-react/diagram/ports.md
@@ -1,43 +1,42 @@
---
layout: post
-title: Ports in React Diagram component | Syncfusion®
-description: Learn here all about Ports in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Ports in React Diagram Component | Syncfusion®
+description: Learn here all about Ports in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Ports
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Ports in React Diagram component
+# Ports in React Diagram Component
-Port is a special connection point in a Node where you can glue the connectors. When you glue a connector to a node or port, they remain connected even if one of the nodes is moved.
+Ports are specialized connection points on nodes that provide precise control over where connectors attach. Unlike node-to-node connections that automatically adjust their attachment points, ports maintain fixed connection locations even when nodes are moved, rotated, or resized. This makes ports essential for creating stable, predictable diagram layouts and professional flowcharts.

-## Types of connections
+## Types of Connections
-There are two main types of connections, node to node and port to port. The difference between these two connections is whether or not a connector remains glued to a specific connection point when you move the attached node or connector.
+The Diagram component supports two distinct connection methods, each serving different use cases depending on the level of connection control required.
-### Node to node connection
+### Node to Node Connection
-A node to node connection is one where the connector will move around the node as you move the node. Diagram will always ensure the connector in the shortest, most direct line possible. You can create a node to node connection by selecting the entire node (rather than the port) and connect it to another shape (rather than to a port).
+Node to node connections automatically find the optimal attachment point on a node's boundary. When either connected node moves, the connector dynamically repositions to maintain the shortest path between nodes. This connection type works best for simple diagrams where precise connection points are not critical.
-
-
-When a connector is connected between two nodes, its end points are automatically docked to the node’s nearest boundary as shown in the following Gif.
+When a connector is connected between two nodes, its end points are automatically docked to the node's nearest boundary as shown in the following gif.

-### Port to port connection
-
-Ports act as the connection points of the node and allows creating connections with only those specific points as shown in the following image.
+### Port to Port Connection
+Port to port connections attach to specific, predefined points on nodes. These connections remain fixed to their designated ports regardless of node movement, ensuring consistent diagram appearance and reliable connector behavior. This connection type is ideal for technical diagrams, flowcharts, and any scenario requiring precise connector placement.

-## Create port
+## Create Port
-To add a connection port, define the port object and add it to node’s [`ports`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/) collection. The [`offset`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointModel/) property of the port accepts an object of fractions and is used to determine the position of ports. The following code explains how to add ports when initializing the node.
+Ports are defined as objects within a node's [`ports`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/) collection. The [`offset`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointModel/) property accepts fractional values (0 to 1) that determine the port's position relative to the node's bounds, where (0,0) represents the top-left corner and (1,1) represents the bottom-right corner.
+
+The following code demonstrates how to add ports during node initialization:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -52,12 +51,11 @@ To add a connection port, define the port object and add it to node’s [`ports`
N> When setting a Port's ID, ensure that it does not contain white spaces, does not start with numbers or special characters, and does not include special characters like underscores (_) or spaces.
-## Add ports at runtime
+## Add Ports at Runtime
-You can add ports to the nodes at runtime by using the diagram method [`addPorts`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addports). The following code illustrates how to add ports to node at runtime.
+The [`addPorts`](https://ej2.syncfusion.com/react/documentation/api/diagram/#addports) method enables dynamic port creation after the diagram has been initialized. This functionality is useful for interactive applications where users can customize node connection points or when ports need to be added based on business logic.
-The port’s ID property is used to define the unique ID for the port and its further used to find the port at runtime.
-If ID is not set, then default ID is automatically set.
+The port's ID property defines a unique identifier that can be used to reference the port in subsequent operations. If no ID is specified, the system automatically generates a default ID.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -70,9 +68,9 @@ If ID is not set, then default ID is automatically set.
{% previewsample "page.domainurl/code-snippet/diagram/ports/ports-cs2" %}
-## Remove ports at runtime
+## Remove Ports at Runtime
-You can remove ports at runtime by using diagram method [`removePorts`](https://ej2.syncfusion.com/react/documentation/api/diagram/#removeports).Refer to the following example which shows how to remove ports at runtime.
+The[`removePorts`](https://ej2.syncfusion.com/react/documentation/api/diagram/#removeports) method allows dynamic removal of ports from nodes. When a port is removed, any connectors attached to that port are automatically disconnected. This method is particularly useful for creating adaptive interfaces or cleaning up unused connection points.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -85,9 +83,9 @@ You can remove ports at runtime by using diagram method [`removePorts`](https://
{% previewsample "page.domainurl/code-snippet/diagram/ports/ports-cs3" %}
-## Update port at runtime
+## Update Port at Runtime
-You can change any port properties at runtime and update it through the diagram method [`dataBind`].
+Port properties can be modified at runtime by directly updating the port object and calling the [`dataBind`] method to apply the changes. This approach enables dynamic customization of port appearance, position, and behavior based on application state or user interactions.
The following code example illustrates how to change the port offset at runtime.
@@ -102,9 +100,9 @@ The following code example illustrates how to change the port offset at runtime.
{% previewsample "page.domainurl/code-snippet/diagram/ports/ports-cs4" %}
-## Specify connection direction to port
+## Specify Connection Direction to Port
-The [`connectionDirection`](https://ej2.syncfusion.com/react/documentation/api/diagram/port/#connectiondirection) property of a port allows users to specify the direction in which a connector should establish a connection. This can be either to the port (incoming) or from the port (outgoing).
+The [`connectionDirection`](https://ej2.syncfusion.com/react/documentation/api/diagram/port/#connectiondirection) property controls the allowed connection flow through a port. This property accepts values that specify whether connectors can connect to the port (incoming), from the port (outgoing), or both directions. This feature is essential for creating directional flowcharts and enforcing proper data flow in technical diagrams.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -119,9 +117,9 @@ The [`connectionDirection`](https://ej2.syncfusion.com/react/documentation/api/d

-## InEdges and outEdges of ports
+## InEdges and OutEdges of Ports
-The [`inEdges`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/#inedges) is used to get the incoming connectors of the port that are connected to the port. [`outEdges`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/#outedges)is used to get the outgoing connectors of the port that are connected to the port.
+Each port maintains collections of its connected connectors through read-only properties.The [`inEdges`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/#inedges) property contains the IDs of all connectors that terminate at the port, while [`outEdges`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/#outedges) contains the IDs of connectors that originate from the port. These properties are automatically maintained by the diagram and provide valuable information for traversing connection relationships.
The `inEdges` and `outEdges` of the port are read-only and cannot be customized.
@@ -138,15 +136,14 @@ The `inEdges` and `outEdges` of the port are read-only and cannot be customized.
The following code example shows how to get inEdges and outEdges of port.
-## Additional information to port
+## Additional Information to Port
-The[ `addInfo`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/#addinfo) property of the port allows you to maintain additional information to the port.
+The[ `addInfo`](https://ej2.syncfusion.com/react/documentation/api/diagram/pointPortModel/#addinfo) property allows attachment of custom metadata to ports. This property accepts any object and is useful for storing application-specific data, configuration settings, or contextual information that needs to be associated with particular ports. The stored information persists with the port throughout its life cycle and can be accessed when processing port-related events or operations.
-The following code example shows how to set addInfo to the port.
+The following code example shows how to attach additional information to a port:
```ts
let port:PointPortModel = {id:'port1',offset:{x:0.5,y:0},addInfo:{position:'TopCenter',id:'port1'}};
-```
-
+```
\ No newline at end of file
diff --git a/ej2-react/diagram/print.md b/ej2-react/diagram/print.md
index b11488920..97d2d1e22 100644
--- a/ej2-react/diagram/print.md
+++ b/ej2-react/diagram/print.md
@@ -1,6 +1,6 @@
---
layout: post
-title: Print in React Diagram control | Syncfusion®
+title: Print in React Diagram Component | Syncfusion®
description: Check out and learn about getting started with print in React Diagram Component of Syncfusion Essential® JS 2 and more details.
control: Print
platform: ej2-react
@@ -8,9 +8,9 @@ documentation: ug
domainurl: ##DomainURL##
---
-# Print in React Diagram control
+# Print in React Diagram Component
-The [`print`](https://ej2.syncfusion.com/react/documentation/api/diagram/#print) method helps to print the diagram as image.
+The React Diagram component provides comprehensive printing capabilities that allow users to generate high-quality printed outputs of their diagrams. The [`print`](https://ej2.syncfusion.com/react/documentation/api/diagram/#print) method enables printing the diagram as an image with extensive customization options for different printing scenarios.
```JavaScript
@@ -41,25 +41,25 @@ To print the React Diagram elements in various formats, refer to the video link
## Print Options
-The diagram can be customized while printing using the following properties of [`printOptions`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPrintOptions/).
+The diagram printing behavior can be extensively customized using the [`printOptions`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPrintOptions/)parameter. These options provide control over the printed output's layout, size, and content selection.
-The available print options are listed in the table below.
+The available print options are detailed in the table below:
-| Name | Type | Description|
-|-------- | -------- | -------- |
-| region | enum | Sets the region of the diagram to be printed. |
-| margin | object | Sets the margin of the page to be printed. |
-| stretch| enum | Resizes the diagram content to fill its allocated space and printed.|
-| multiplePage | boolean | Prints the diagram into multiple pages. |
-| pageWidth | number | Sets the page width of the diagram while printing the diagram into multiple pages. |
-| pageHeight| number | Sets the page height of the diagram while printing the diagram into multiple pages.|
-| pageOrientation | enum | Sets the orientation of the page. |
+| Name | Type | Description| Example Values |
+|-------- | -------- | -------- | -------- |
+| region | enum | Specifies the region of the diagram to be printed. Options include 'Content', 'PageSettings'. | 'Content', 'PageSettings' |
+| margin | object | Sets the margin spacing around the printed content in pixels. | { left: 10, top: 10, bottom: 10, right: 10 } |
+| stretch| enum | Resizes the diagram content to fit the allocated print space. Options include 'Stretch', 'Meet', 'Slice'. | 'Stretch', 'Meet' |
+| multiplePage | boolean | Enables printing the diagram across multiple pages when content exceeds single page dimensions. | true, false |
+| pageWidth | number | Defines the width of each page in pixels when using multiple page printing. | 816, 1056 |
+| pageHeight| number | Sets the height of each page in pixels for multiple page printing scenarios. | 1056, 816 |
+| pageOrientation | enum | Controls the page orientation for the printed output. | 'Landscape', 'Portrait' |
### Region
-Printing particular region of diagram is possible by using the [`region`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPrintOptions/#region) property of the [`printOptions`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPrintOptions/).
+The [`region`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPrintOptions/#region) property allows selective printing of specific diagram areas. This feature is particularly useful when working with large diagrams where only certain sections need to be printed.
-The following code example illustrates how to print the diagram based on region.
+The following code example illustrates how to print the diagram based on different regions:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -73,11 +73,11 @@ The following code example illustrates how to print the diagram based on region.
{% previewsample "page.domainurl/code-snippet/diagram/print/print-cs1" %}
-### Multiple page
+### Multiple Page
-Printing a diagram across multiple pages is possible by setting the [`multiplePage`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPrintOptions/#multiplepage) property of `printOptions` to true.
+Large diagrams can be printed across multiple pages by setting the [`multiplePage`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPrintOptions/#multiplepage) property to true. This feature automatically divides the diagram content across multiple print pages while maintaining proper scaling and alignment.
-The following code example demonstrates how to set multiplePage to true:
+The following code example demonstrates how to enable multiple page printing:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -107,9 +107,9 @@ The margin for the print region can be set using the [`margin`](https://ej2.sync
{% previewsample "page.domainurl/code-snippet/diagram/print/print-cs3" %}
-### Page width and Page height
+### Page Width and Page Height
-The [`pageHeight`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPrintOptions/#pageheight) and [`pageWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPrintOptions/#pagewidth) property of `printOptions` is used to set the size of the printing image. The following example demonstrates how to set the pageWidth and pageHeight.
+The [`pageHeight`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPrintOptions/#pageheight) and [`pageWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPrintOptions/#pagewidth) properties control the dimensions of the printed output. These settings are particularly important when printing to specific paper sizes or when precise scaling is required.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -125,12 +125,12 @@ The [`pageHeight`](https://ej2.syncfusion.com/react/documentation/api/diagram/iP
### Page Orientation
-[`pageOrientation`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPrintOptions/#pageorientation) of `printOptions` is used to set the orientation of the page to be printed.
+[`pageOrientation`](https://ej2.syncfusion.com/react/documentation/api/diagram/iPrintOptions/#pageorientation)property determines how the diagram is oriented on the printed page:
-* Landscape - Display with page Width is more than the page Height.
-* Portrait - Display with page Height is more than the page width.
+* **Landscape** - Prints with page width greater than page height, ideal for wide diagrams
+* **Portrait** - Prints with page height greater than page width, suitable for tall diagrams
-The following example shows how to set pageOrientation for the printOptions.
+The following example shows how to configure page orientation:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -144,11 +144,9 @@ The following example shows how to set pageOrientation for the printOptions.
{% previewsample "page.domainurl/code-snippet/diagram/print/print-cs5" %}
-
## Limitations
-
-Currently, printing diagram with native and HTML nodes is not supported. To overcome this limitation, we make use of the Syncfusion® Essential® PDF library. This library incorporates the Syncfusion® Essential® HTML converter, which employs the advanced Blink rendering engine. This converter seamlessly transforms HTML content into images. Refer to [`export Html-and-Native node`](https://support.syncfusion.com/kb/article/15530/how-to-print-or-export-the-html-and-native-node-into-image-format-using-react-diagram) kb for more information.
+Currently, printing diagrams containing native and HTML nodes is not directly supported due to browser security restrictions. To address this limitation, Syncfusion provides integration with the Syncfusion® Essential® PDF library. This library includes the Syncfusion® Essential® HTML converter, which utilizes the advanced Blink rendering engine to convert HTML content into printable images.Refer to [`export Html-and-Native node`](https://support.syncfusion.com/kb/article/15530/how-to-print-or-export-the-html-and-native-node-into-image-format-using-react-diagram) kb for more information.
## See Also
diff --git a/ej2-react/diagram/radial-layout.md b/ej2-react/diagram/radial-layout.md
index fbccbb853..f2da63946 100644
--- a/ej2-react/diagram/radial-layout.md
+++ b/ej2-react/diagram/radial-layout.md
@@ -1,24 +1,24 @@
---
layout: post
-title: Radial tree layout in React Diagram component | Syncfusion®
-description: Learn here all about Radial tree layout in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Radial tree layout in React Diagram Component | Syncfusion®
+description: Learn here all about Radial tree layout in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Radial tree layout
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Radial tree layout in React Diagram control
+# Radial Tree Layout in React Diagram Component
-A Radial tree layout is a diagram that presents information in a hierarchical structure, with a central node at the core of the diagram. The central node represents the main concept or topic, and branches extend outward in a radial fashion, creating a tree-like structure. The layout [`root`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#root) property can be used to define the root node of the layout. When no root node is set, the algorithm automatically considers the node without any incoming edges (InEdges connector count of 0) as the root node. To create radial tree, the [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#type) of the layout as `RadialTree`.
+A radial tree layout is a specialized diagram that presents hierarchical information with a central node at the core, surrounded by branches extending outward in a circular, tree-like structure. This layout is particularly effective for visualizing organizational charts, family trees, mind maps, and network relationships where understanding the relationship distance from a central concept is important.
-The RadialTree layout provides support for adding space between the nodes. The [`HorizontalSpacing`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#horizontalspacing )and [`VerticalSpacing`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#verticalspacing) properties of the layout allow you to set the space between the nodes. The arrangement results in an ever-expanding concentric arrangement with radial proximity to the root node indicating the node level in the hierarchy.
+The central node represents the main concept or topic, with child nodes arranged in concentric circles based on their hierarchical level. The layout [`root`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#root)property can be used to define the root node of the layout. When no root node is specified, the algorithm automatically identifies the node without any incoming edges (InEdges connector count of 0) as the root node. To create a radial tree, set the [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#type) of the layout to **RadialTree**.
+The RadialTree layout provides comprehensive support for controlling node spacing and arrangement. The [`HorizontalSpacing`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#horizontalspacing )and [`VerticalSpacing`](https://ej2.syncfusion.com/react/documentation/api/diagram/layoutModel/#verticalspacing) properties allow precise control over the space between nodes, measured in pixels. The arrangement creates an expanding concentric pattern where radial proximity to the root node indicates the hierarchical level.
-## Radial tree with DataSource
-
-You can create a radial tree layout with DataSource. The following code example illustrates how to create a radial tree layout using a data source.
+## Radial Tree with DataSource
+Creating a radial tree layout with a data source provides automatic node generation and connection management. This approach is ideal when working with structured data objects that define hierarchical relationships.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -33,13 +33,12 @@ You can create a radial tree layout with DataSource. The following code example
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/radiallayout-cs1" %}
->Note: If you want to convert the data source into layout, you need to inject DataBinding along with RadialTree module in the diagram.
-
+>Note: When converting a data source into a radial layout, inject both DataBinding and RadialTree modules in the diagram component.
-## Radial tree with nodes and connectors
-You can render a radial tree layout without using DataSource. The following code demonstrates how to render a radial tree layout without using data source.
+## Radial Tree with Nodes and Connectors
+For scenarios requiring manual control over node creation and positioning, the radial tree layout can be applied to explicitly defined nodes and connectors. This approach offers greater flexibility for custom node styling and specific layout requirements.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -54,6 +53,6 @@ You can render a radial tree layout without using DataSource. The following code
{% previewsample "page.domainurl/code-snippet/diagram/AutomaticLayout/radiallayout-cs1" %}
->Note: If you want to use radial tree layout in diagram, you need to inject RadialTree in the diagram.
+>Note: To use radial tree layout functionality, inject the RadialTree module in the diagram component.

\ No newline at end of file
diff --git a/ej2-react/diagram/ruler.md b/ej2-react/diagram/ruler.md
index 1b28f61a4..b31d9cb17 100644
--- a/ej2-react/diagram/ruler.md
+++ b/ej2-react/diagram/ruler.md
@@ -1,23 +1,23 @@
---
layout: post
-title: Ruler in React Diagram component | Syncfusion®
-description: Learn here all about Ruler in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Ruler in React Diagram Component | Syncfusion®
+description: Learn here all about Ruler in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Ruler
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Ruler in React Diagram component
+# Ruler in React Diagram Component
-The ruler provides horizontal and vertical guides for measuring in the diagram control. It can be used to measure diagram objects, indicate positions, and align diagram elements, making it especially useful for creating scale models.The ruler also includes a position indicator that displays the precise location of the mouse cursor on the diagram canvas, with the default color of the position indicator marker being red.
+The ruler provides horizontal and vertical guides for measuring in the diagram control. It can be used to measure diagram objects, indicate positions, and align diagram elements, making it especially useful for creating scale models. The ruler also includes a position indicator that displays the precise location of the mouse cursor on the diagram canvas, with the default color of the position indicator marker being red.
-## Define rulers
+The diagram ruler consists of two components: a horizontal ruler displayed along the top edge and a vertical ruler along the left edge of the diagram canvas. Both rulers work together to provide comprehensive positioning and measurement capabilities.
-The [`rulerSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/rulerSettings/) property of diagram is used to control the visibility and appearance of the ruler in the diagram.
-
-The [`showRulers`](https://ej2.syncfusion.com/react/documentation/api/diagram/rulerSettings/#showrulers) property is used to show or hide the rulers in the diagram.
+## Define Rulers
+The [`rulerSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/rulerSettings/) property of diagram controls the visibility and appearance of the ruler in the diagram.
+The [`showRulers`](https://ej2.syncfusion.com/react/documentation/api/diagram/rulerSettings/#showrulers) property shows or hides the rulers in the diagram.
The following code shows how to add a ruler to the diagram.
@@ -34,16 +34,22 @@ The following code shows how to add a ruler to the diagram.
## Customizing the Ruler
-[`horizontalRuler`](https://ej2.syncfusion.com/react/documentation/api/diagram/rulerSettings/#horizontalruler) and [`verticalRuler`](https://ej2.syncfusion.com/react/documentation/api/diagram/rulerSettings/#verticalruler) properties of `rulerSettings` are used to customize the rulers appearance in the diagram.
+The [`horizontalRuler`](https://ej2.syncfusion.com/react/documentation/api/diagram/rulerSettings/#horizontalruler) and [`verticalRuler`](https://ej2.syncfusion.com/react/documentation/api/diagram/rulerSettings/#verticalruler) properties of `rulerSettings` customize the rulers appearance in the diagram.
+
+By default, the ruler segments are arranged based on pixel values, with each segment representing a unit of measurement on the diagram canvas.
+
+### Ruler Spacing and Dimensions
+The [`interval`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#interval) property defines the spacing between ruler segments, while the [`segmentWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#segmentwidth) property sets the width of each segment.
+These properties apply to both horizontal and vertical rulers.
-By default, the ruler segments are arranged based on pixel values.
+### Tick Alignment
-The HorizontalRuler’s [`interval`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#interval) property defines the spacing between ruler segments, and the[`segmentWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#segmentwidth) property sets the width of each segment. Similarly, the VerticalRuler’s [`interval`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#interval) and [`segmentWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#segmentwidth) properties control the interval and segment width for the vertical ruler.
+The [`tickAlignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#tickalignment) property controls the positioning of ruler tick marks. For the horizontal ruler, ticks can be aligned to the left or right side, while for the vertical ruler, they can be aligned to the top or bottom.
-The HorizontalRuler’s [`tickAlignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#tickalignment) property aligns the ruler ticks to the left or right side, while the VerticalRuler’s [`tickAlignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#tickalignment) aligns them to the top or bottom.
+### Ruler Thickness
-The HorizontalRuler’s [`thickness`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#thickness) property sets the thickness of the horizontal ruler, and the VerticalRuler’s [`thickness`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#thickness) property sets the thickness of the vertical ruler.
+The [`thickness`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#thickness) property sets the thickness of the ruler display area for both horizontal and vertical rulers.
The following code shows how the diagram ruler can be customized.
@@ -59,11 +65,11 @@ The following code shows how the diagram ruler can be customized.
{% previewsample "page.domainurl/code-snippet/diagram/ruler/customRuler-cs1" %}
-### Arrange tick
+### Arrange Tick
-The HorizontalRuler’s [`arrangeTick`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#arrangetick) and VerticalRuler’s [`arrangeTick`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#arrangetick) functions allow you to customize the appearance of ruler ticks. These functions are called for each tick rendering.
+The [`arrangeTick`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#arrangetick) function allows customization of ruler tick appearance for both horizontal and vertical rulers. This function is called during the rendering of each tick mark, providing control over tick properties such as length and style.
-The following code demonstrates how to use the `arrangeTick` function to customize the tickLength.
+The following code demonstrates how to use the `arrangeTick` function to customize the tick length.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -76,8 +82,8 @@ The following code demonstrates how to use the `arrangeTick` function to customi
{% previewsample "page.domainurl/code-snippet/diagram/ruler/customRuler-cs2" %}
-### Marker color
+### Marker Color
-The HorizontalRuler’s [`markerColor`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#markercolor) and VerticalRuler’s [`markerColor`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#markercolor) properties are used to define the ruler marker color and marker will be shown while hovering mouse over the diagram canvas.
+The HorizontalRuler’s [`markerColor`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramRuler/#markercolor)property defines the ruler marker color for both horizontal and vertical rulers. The marker appears when hovering the mouse over the diagram canvas, providing precise position feedback.
N> The MarkerColor property can be customized using the [`marker`](./style/#customizing-the-ruler) CSS style.
\ No newline at end of file
diff --git a/ej2-react/diagram/scroll-settings.md b/ej2-react/diagram/scroll-settings.md
index 2a0621ece..7e5927884 100644
--- a/ej2-react/diagram/scroll-settings.md
+++ b/ej2-react/diagram/scroll-settings.md
@@ -1,26 +1,26 @@
---
layout: post
-title: Scroll settings in React Diagram component | Syncfusion®
-description: Learn here all about Scroll settings in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Scroll settings in React Diagram Component | Syncfusion®
+description: Learn here all about Scroll settings in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Scroll settings
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Scroll settings in React Diagram component
+# Scroll Settings in React Diagram Component
-The diagram can be scrolled using both the vertical and horizontal scrollbars. Additionally, the mouse wheel can be used to scroll the diagram. The diagram's [`scrollSettings`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/) allow you to read the current scroll status, view port size, current zoom level, and zoom factor. These settings also provide the capability to programmatically control the scrolling of the diagram.
+The diagram component provides comprehensive scrolling capabilities through both vertical and horizontal scrollbars, as well as mouse wheel navigation. The diagram's [`scrollSettings`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/) enable developers to monitor the current scroll status, viewport dimensions, zoom levels, and programmatically control diagram navigation. These settings are essential for managing large diagrams and providing smooth user interaction experiences.
## Access and Customize Scroll Settings
-Scroll settings in a diagram allow you to access and customize various properties such as [`horizontalOffset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#horizontaloffset), [`verticalOffset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#verticaloffset), [`viewPortWidth`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#viewportwidth), [`viewPortHeight`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#viewportheight), [`currentZoom`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#currentzoom), [`zoomFactor`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#zoomfactor), [`maxZoom`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#maxzoom), [`minZoom`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#minzoom), [`scrollLimit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#scrolllimit), [`canAutoScroll`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#canautoscroll), [`autoScrollBorder`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/), [`padding`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/), [`scrollableArea`](https://helpej2.syncfusion.com/react/documentation/api/diagram/rect/).
+Scroll settings in a diagram provide access to various properties that control navigation and viewport behavior, including [`horizontalOffset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#horizontaloffset), [`verticalOffset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#verticaloffset), [`viewPortWidth`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#viewportwidth), [`viewPortHeight`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#viewportheight), [`currentZoom`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#currentzoom), [`zoomFactor`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#zoomfactor), [`maxZoom`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#maxzoom), [`minZoom`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#minzoom), [`scrollLimit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#scrolllimit), [`canAutoScroll`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#canautoscroll), [`autoScrollBorder`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/), [`padding`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/), [`scrollableArea`](https://helpej2.syncfusion.com/react/documentation/api/diagram/rect/).
-These properties enable you to read and adjust the scroll status, scroll offset, zoom levels, and more. For a comprehensive overview of these properties, refer to the [`Scroll Settings`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/)
+These properties enable developers to read and adjust the scroll status, scroll offsets, zoom levels, and scrolling behavior. For a comprehensive overview of all available properties, refer to the[`Scroll Settings`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/)
-## Define scroll offset
+## Define Scroll Offset
-The diagram allows you to pan before loading, ensuring that any desired region of a large diagram is visible. You can programmatically pan the diagram using the [`horizontalOffset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#horizontaloffset) and [`verticalOffset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#verticaloffset) properties of the scroll settings. The following code illustrates how to programmatically pan the diagram upon initialization also defined scrollLimit as 'Infinity' to scroll infinitely in diagram. To learn more about scrollLimit refer to [`scrollLimit`](https://ej2.syncfusion.com/react/documentation/diagram/scroll-settings#scroll-limit)
+The diagram allows developers to set the initial scroll position before loading, ensuring that any desired region of a large diagram is immediately visible. The initial scroll position can be programmatically configured using the `horizontalOffset` and `verticalOffset` properties of the scroll settings. The following code illustrates how to programmatically set the diagram's initial scroll position upon initialization, with `scrollLimit` defined as 'Infinity' to enable infinite scrolling. To learn more about scroll limits, refer to the `scrollLimit`
In the example below, the vertical scrollbar is scrolled down by 100 px, and the horizontal scrollbar is scrolled to the right by 100 px.
@@ -35,18 +35,18 @@ In the example below, the vertical scrollbar is scrolled down by 100 px, and the
{% previewsample "page.domainurl/code-snippet/diagram/Tools/polygon-cs1" %}
-## Update scroll offset at runtime
+## Update Scroll Offset at Runtime
-There are several ways to update the scroll offset at runtime:
+The diagram provides multiple methods to update scroll offsets during runtime:
-* `Scrollbar`: Use the horizontal and vertical scrollbars of the diagram.
-* `Mousewheel`: Scroll vertically with the mouse wheel. Hold the Shift key while scrolling to scroll horizontally.
-* `Pan Tool`: Activate the ZoomPan [`tool`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTools/) in the diagram to scroll by panning.
-* `Touch`: Use touch pad gestures for scrolling.
+* **Scrollbar**: Use the horizontal and vertical scrollbars of the diagram for direct navigation.
+* **Mouse wheel**: Scroll vertically with the mouse wheel. Hold the Shift key while scrolling to scroll horizontally.
+* **Pan Tool**: Activate the ZoomPan [`tool`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTools/) in the diagram to scroll by panning.
+* **Touch**: Use touch pad gestures for smooth scrolling on touch-enabled devices.
-### Programmatically update Scroll Offset
+### Programmatically Update Scroll Offset
-You can programmatically change the scroll offsets of diagram by customizing the [`horizontalOffset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#horizontaloffset) and [`verticalOffset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#verticaloffset) of [`Scroll Settings`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/) at runtime. The following code illustrates how to change the scroll offsets at runtime.
+The scroll offsets of the diagram can be programmatically modified by customizing the `horizontalOffset` and `verticalOffset` of [`Scroll Settings`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/)at runtime. The following code demonstrates how to change the scroll offsets dynamically.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -59,33 +59,33 @@ You can programmatically change the scroll offsets of diagram by customizing the
{% previewsample "page.domainurl/code-snippet/diagram/Tools/polygon-cs2" %}
-## Update zoom at runtime
+## Update Zoom at Runtime
-### Zoom using mouse wheel
+### Zoom Using Mouse Wheel
-Another way to zoom in and out the diagram is by using the mouse wheel. This method is a quick and convenient way to zoom in and out without having to use any additional tools or gestures.
+The mouse wheel provides a convenient method to zoom in and out of the diagram quickly without requiring additional tools or gestures.
-- Zoom in: Press Ctrl+mouse wheel, then scroll upward.
+- **Zoom in**: Press Ctrl+mouse wheel, then scroll upward.
-- Zoom out: Press Ctrl+mouse wheel, then scroll downward.
+- **Zoom out**: Press Ctrl+mouse wheel, then scroll downward.
-### Zoom using Keyboard Shortcuts
+### Zoom Using Keyboard Shortcuts
-Using keyboard shortcuts is a quick and easy way to zoom the diagram without having to use the mouse or touch pad.
+Keyboard shortcuts offer a quick and efficient way to zoom the diagram without using the mouse or touch pad.
-- Zoom in: Press Ctrl and the plus(+) key.
+- **Zoom in**: Press Ctrl and the plus (+) key.
-- Zoom out: Press Ctrl and the minus(-) key.
+- **Zoom out**: Press Ctrl and the minus (-) key.
-### Programmatically update zoom
+### Programmatically Update Zoom
-You can programmatically change the current zoom of diagram by utilizing the [`zoomTo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#zoomto) public method.
+The current zoom level of the diagram can be programmatically modified by utilizing the [`zoomTo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#zoomto) public method.
#### ZoomOptions
The [`zoomTo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#zoomto) method takes one parameter [`zoomOptions`](https://helpej2.syncfusion.com/react/documentation/api/diagram/zoomOptions/). In that zoomOptions we can specify the [`focusPoint`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pointModel/), [`type`](https://helpej2.syncfusion.com/react/documentation/api/diagram/zoomTypes/) and [`zoomFactor`](https://helpej2.syncfusion.com/react/documentation/api/diagram/zoomOptions/#zoomfactor)
-The following example shows how to zoom-in and zoom-out the diagram using zoomTo method
+The following example demonstrates how to zoom in and zoom out of the diagram using the zoomTo method:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -102,21 +102,21 @@ For more information on various ways to zoom and pan the diagram, refer to [`zoo
## AutoScroll
-The autoscroll feature automatically scrolls the diagram when a node or connector is moved beyond its boundary. This ensures that the element remains visible during operations like dragging, resizing, and selection.
+The autoscroll feature automatically scrolls the diagram when a node or connector is moved beyond the visible boundary. This functionality ensures that elements remain visible during operations such as dragging, resizing, and selection, providing a seamless user experience.
-The autoscroll behavior triggers automatically when any of the following actions occur towards the edges of the diagram:
+The autoscroll behavior activates automatically when any of the following actions occur near the edges of the diagram:
-- Node dragging or resizing
-- Connector control point editing
-- Rubber band selection
+- Node dragging or resizing operations.
+- Connector control point editing.
+- Rubber band selection.
-The client-side event [`ScrollChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iScrollChangeEventArgs/) is triggered when autoscroll occurs, allowing for customizations. Refer [`scrollChange-event`](https://ej2.syncfusion.com/react/documentation/diagram/scroll-settings#scroll-change-event) for more information.
+The client-side event [`ScrollChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iScrollChangeEventArgs/) is triggered when autoscroll occurs, enabling custom behavior implementation. Refer to the [`scrollChange-event`](https://ej2.syncfusion.com/react/documentation/diagram/scroll-settings#scroll-change-event) for more information.
Autoscroll behavior can be enabled or disabled using the [`canAutoScroll`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#canautoscroll) property of the diagram.
### Autoscroll border
-The autoscroll border defines the maximum distance from the mouse pointer to the diagram edge that triggers autoscroll. By default, this distance is set to 15 pixels for all sides (left, right, top, and bottom). You can adjust this using the [`autoScrollBorder`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/) property of the scroll settings.
+The autoscroll border defines the maximum distance from the mouse pointer to the diagram edge that triggers autoscroll behavior. By default, this distance is set to 15 pixels for all sides (left, right, top, and bottom). This distance can be customized using the[`autoScrollBorder`](https://helpej2.syncfusion.com/react/documentation/api/diagram/marginModel/) property of the scroll settings.
The following example demonstrates how to configure autoscroll:
@@ -135,7 +135,7 @@ N> To use auto scroll the scrollLimit should be set as 'Infinity'
### Controlling Autoscroll Speed
-You can control how often the scrolling needs to be performed automatically in the Diagram component during the auto-scrolling behavior. You can now adjust the frequency, ranging from slow and smooth to quick and rapid, to suit their preferences. To configure, set the value in milliseconds to the [`autoScrollFrequency`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#autoscrollfrequency) property within the scrollSettings class, allowing precise control over how often auto-scrolling occurs.
+The frequency of automatic scrolling in the Diagram component during autoscroll behavior can be precisely controlled. The scrolling frequency can be adjusted from slow and smooth to quick and rapid to suit different requirements. Configure this by setting a value in milliseconds to the[`autoScrollFrequency`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#autoscrollfrequency) property within the scrollSettings, allowing precise control over autoscroll timing.

@@ -143,11 +143,11 @@ You can control how often the scrolling needs to be performed automatically in t
The [`scrollLimit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/scrollSettingsModel/#scrolllimit) allows you to define the scrollable region of the diagram. It includes the following options:
-* `Infinity`: Allows scrolling in all directions without any restriction.
-* `Diagram`: Allows scrolling within the diagram region.
-* `Limited`: Allows scrolling within a specified scrollable area.
+* **Infinity**: Allows scrolling in all directions without any restriction.
+* **Diagram**: Allows scrolling within the diagram region only.
+* **Limited**: Allows scrolling within a specified scrollable area.
-The `scrollLimit` property in scroll settings helps to define these limits.
+The `scrollLimit` property in scroll settings helps to define these scrolling boundaries.
### Scrollable Area
@@ -185,7 +185,7 @@ The following code example illustrates how to set scroll padding for the diagram
## Reset scroll
-The [`reset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#reset) method resets the zoom and scroller offsets to their default values.
+The [`reset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#reset) method resets both the zoom level and scroller offsets to their default values. This is useful for returning the diagram to its initial state after user interactions.
``` javascript
//Resets the scroll and zoom to default values
@@ -193,9 +193,10 @@ diagramInstance.reset();
```
-## UpdateViewport
+## Update Viewport Dimensions
+
+The [`updateViewPort`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#updateviewport) method is used to update the dimensions of the diagram viewport. This method is typically called when the diagram container size changes or when dynamic resizing is required.
-The [`updateViewPort`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#updateviewport) method is used to update the dimensions of the diagram viewport.
```javascript
//Updates diagram viewport
@@ -205,7 +206,7 @@ diagramInstance.updateViewPort();
## Events
-### Scroll change event
+### Scroll Change Event
The [`scrollChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iScrollChangeEventArgs/) event is triggered whenever the scrollbar is updated. This can occur during actions such as zooming in, zooming out, using the mouse wheel, or panning. The following example shows how to capture the `scrollChange` event.
diff --git a/ej2-react/diagram/serialization.md b/ej2-react/diagram/serialization.md
index 573c44285..c758f459c 100644
--- a/ej2-react/diagram/serialization.md
+++ b/ej2-react/diagram/serialization.md
@@ -1,26 +1,33 @@
---
layout: post
-title: Serialization in React Diagram component | Syncfusion®
-description: Learn here all about Serialization in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Serialization in React Diagram Component | Syncfusion®
+description: Learn here all about Serialization in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Serialization
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Serialization in React Diagram component
+# Save and Load Diagrams in React Diagram Component
-**Serialization** is the process of converting the state of the diagram into a format that can be saved and later restored. This ensures that the diagram's current state, including its nodes, connectors, and configurations, can be persisted across sessions.
+**Serialization** is the process of converting the diagram's current state into a storage format that can be saved and later restored. This feature ensures that all diagram elements, including nodes, connectors, and their configurations, persist across application sessions.
-Serialization involves saving the diagram's state as a JSON string, which can then be stored in a database, file, or other storage medium. When needed, the serialized string can be deserialized to recreate the diagram in its previous state.
+The serialization process converts the diagram into a JSON string format, which can be stored in databases, files, or other storage systems. When needed, this serialized data can be deserialized to recreate the diagram exactly as it was previously configured.
-To easily save the contents of the diagram as a JSON string or file stream, and load it from the saved file, refer to the video link below.
+Use serialization when you need to:
+- Save user-created diagrams for future editing.
+- Implement undo/redo functionality.
+- Create diagram templates.
+- Transfer diagrams between different sessions or users.
+To save and load the diagram in React, refer to the below video link.
{% youtube "https://www.youtube.com/watch?v=IkWXjhRE-o0" %}
-## Save
+## Saving Diagrams
-The diagram is serialized as string while saving. The client-side method, [`saveDiagram`](https://ej2.syncfusion.com/react/documentation/api/diagram/#savediagram), helps to serialize the diagram as a string. This method captures the entire diagram's configuration and content, converting it into a string representation.
+### Basic Save Operation
+
+The [`saveDiagram`](https://ej2.syncfusion.com/react/documentation/api/diagram/#savediagram) method serializes the entire diagram configuration into a JSON string. This method captures all diagram elements, their properties, and the current state.
The following code illustrates how to save the diagram:
@@ -32,7 +39,7 @@ saveData = diagramInstance.saveDiagram();
```
-This JSON string can be stored in local storage for future use. The following code illustrates how to save the serialized string into local storage and how to retrieve it:
+The serialized JSON string can be stored in various storage systems. The following example demonstrates local storage implementation:
```ts
//Saves the string in to local storage
@@ -43,11 +50,15 @@ saveData = localStorage.getItem('fileName');
```
-The diagram can also be saved as raster or vector image files. For more information about saving the diagram as images, refer to the [`Print`](./print) and [`Export`](./export) section.
+### Alternative Save Formats
+
+The diagram can also be saved as raster or vector image files. For more information about saving the diagram as images, refer to the [`Print`](./print) and [`Export`](./export) sections.
+
+## Loading Diagrams
-## Load
+### Basic Load Operation
-The diagram can be loaded from serialized string data using the [`loadDiagram`](https://ej2.syncfusion.com/react/documentation/api/diagram/#loaddiagram) method. The saved string should be passed as the parameter of the loadDiagram method. The following code illustrates how to load the diagram from serialized string data:
+The [`loadDiagram`](https://ej2.syncfusion.com/react/documentation/api/diagram/#loaddiagram) method recreates the diagram from serialized JSON data. This method accepts the previously saved JSON string as a parameter.
```ts
@@ -60,11 +71,11 @@ diagramInstance.loadDiagram(saveData);
```
->Note: Before loading a new diagram, existing diagram is cleared.
+>Note: Before loading a new diagram, the existing diagram content is automatically cleared.
-## Loaded Event
+### Handling Load Completion
-The [`loaded`](https://ej2.syncfusion.com/react/documentation/api/diagram/#loaded) event triggers when all diagram elements are loaded using [`loadDiagram`](https://ej2.syncfusion.com/react/documentation/api/diagram/#loaddiagram) method. You can use this event to customize diagram elements during the loading process.
+The [`loaded`](https://ej2.syncfusion.com/react/documentation/api/diagram/#loaded) event triggers when all diagram elements finish loading through the [`loadDiagram`](https://ej2.syncfusion.com/react/documentation/api/diagram/#loaddiagram) method. Use this event to perform post-load customizations or validations.
```ts
return (
@@ -76,7 +87,7 @@ The [`loaded`](https://ej2.syncfusion.com/react/documentation/api/diagram/#loade
```
-The event has two arguments such as name, diagram
+The loaded event provides the following arguments:
**name**
@@ -95,11 +106,9 @@ Users can perform customizations or modifications to the diagram elements once t
## Prevent Default Values
-The [`preventDefaults`](https://ej2.syncfusion.com/react/documentation/api/diagram/serializationSettingsModel/#preventdefaults) property of [`serializationSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/serializationSettingsModel/) is used to simplify the saved JSON object by excluding default properties that are inherent to the diagram. This helps reduce the size of the serialized data and improves efficiency when saving and loading diagrams.
+The [`preventDefaults`](https://ej2.syncfusion.com/react/documentation/api/diagram/serializationSettingsModel/#preventdefaults) property of [`serializationSettings`](https://ej2.syncfusion.com/react/documentation/api/diagram/serializationSettingsModel/) reduces the size of serialized data by excluding default properties. This optimization improves performance when handling large diagrams or frequent save operations.
-By enabling preventDefaults, only properties that you set in diagram are included in the serialized JSON object. This optimization is useful for scenarios where minimizing data size is crucial, such as in applications with large diagrams or when optimizing network transfers.
-
-The following code illustrates how to enable the preventDefaults property to simplify the JSON object:
+When enabled, only explicitly set properties are included in the JSON output, significantly reducing file size and improving load times.
```ts
@@ -112,12 +121,16 @@ The following code illustrates how to enable the preventDefaults property to sim
)
```
+# File-Based Save and Load Operations
-## Save and load diagram using uploader control
+### Using Uploader Component
-The JSON files can be uploaded using the uploader component, where they are parsed to extract the JSON data they contain. To achieve this, configure the uploader component with the saveUrl property to receive uploaded files and store them on the server. Similarly, use the removeUrl property to handle file removal operations on the server.
+JSON files can be uploaded and processed using the uploader component. Configure the uploader with appropriate server endpoints to handle file operations, then parse the uploaded JSON data to load diagrams.
-When a JSON file is uploaded, it undergoes parsing to extract its JSON data. This data is then loaded into the diagram using the [`loadDiagram`](https://ej2.syncfusion.com/react/documentation/api/diagram/#loaddiagram) method.
+The uploader requires:
+- `saveUrl` property for receiving and storing uploaded files.
+- `removeUrl` property for handling file deletion operations.
+- File parsing logic to extract JSON data from uploaded files.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -131,13 +144,20 @@ When a JSON file is uploaded, it undergoes parsing to extract its JSON data. Thi
{% previewsample "page.domainurl/code-snippet/diagram/serialization/serialization-cs1" %}
-## Importing and Exporting Diagrams using Mermaid Syntax
+## Mermaid Syntax Integration
+
+### Overview
+
+The [`Diagram`](https://ej2.syncfusion.com/react/documentation/api/diagram/) component supports importing and exporting diagrams using Mermaid syntax. Mermaid is a markdown-inspired syntax for creating diagrams programmatically, enabling easy diagram creation and sharing across different platforms.
-The [`Diagram`](https://ej2.syncfusion.com/react/documentation/api/diagram/) supports saving diagrams in Mermaid syntax format. Mermaid is a Markdown-inspired syntax that automatically generates diagrams. With this functionality, you can easily create mind maps, flowcharts, and UML sequence diagrams from Mermaid syntax data, simplifying the visualization of complex ideas and processes without manual drawing. Additionally, you can export your mind maps, flowcharts, and UML sequence diagrams to Mermaid syntax, allowing for easy sharing, editing, and use across different platforms.
+This functionality supports:
+- Mind maps
+- Flowcharts
+- UML sequence diagrams
-### Save diagram as Mermaid syntax
+### Saving Diagrams as Mermaid Syntax
- The `saveDiagramAsMermaid` method serializes the diagram into a Mermaid-compatible string format. This method is specifically designed for diagrams that utilize Flowchart and Mind map layouts. The following code illustrates how to save the diagram in Mermaid string format.
+The [`saveDiagramAsMermaid`](https://ej2.syncfusion.com/react/documentation/api/diagram/#savediagramasmermaid) method converts compatible diagrams into Mermaid syntax format. This method works specifically with Flowchart and Mind map layouts.
```javascript
//returns the serialized Mermaid string of the Diagram
@@ -145,11 +165,12 @@ let data = diagramInstance.saveDiagramAsMermaid();
```
-### Load diagram from Mermaid syntax
+### Load Diagram from Mermaid Syntax
-You can load a [diagram](https://ej2.syncfusion.com/react/documentation/api/diagram/) from the serialized Mermaid syntax data using the `loadDiagramFromMermaid` method. The following code illustrates how to load a diagram from a Mermaid string data.
+The [`loadDiagramFromMermaid`](https://ej2.syncfusion.com/react/documentation/api/diagram/#loaddiagramfrommermaid) method creates diagrams from Mermaid syntax data, automatically generating the appropriate layout and styling.
+data.
-#### Load flowchart layout
+#### Load Flowchart Layout
The following example shows how to load flowchart diagram from mermaid syntax.
@@ -165,9 +186,9 @@ The following example shows how to load flowchart diagram from mermaid syntax.
{% previewsample "page.domainurl/code-snippet/diagram/serialization/serialization-cs2" %}
-#### Load mindmap layout
+#### Loading Mind Map Layout
-The following example shows how to load mind map diagram from mermaid syntax.
+The following example demonstrates loading a mind map diagram from Mermaid syntax:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -181,9 +202,9 @@ The following example shows how to load mind map diagram from mermaid syntax.
{% previewsample "page.domainurl/code-snippet/diagram/serialization/serialization-cs3" %}
-#### Load UML Sequence diagram
+#### Loading UML Sequence Diagram
-The following example shows how to load UML Sequence diagram from mermaid syntax.
+The following example demonstrates loading a UML Sequence diagram from Mermaid syntax:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -197,4 +218,4 @@ The following example shows how to load UML Sequence diagram from mermaid syntax
{% previewsample "page.domainurl/code-snippet/diagram/serialization/serialization-cs4" %}
-N> Mermaid syntax-based serialization and deserialization is supported only for Flowchart layout, Mind map layout, and UML Sequence Diagram. Ensure that your Mermaid data aligns with one of these supported layouts to enable successful diagram loading.
\ No newline at end of file
+N> Mermaid syntax-based serialization and deserialization supports only Flowchart layout, Mind map layout, and UML Sequence Diagram. Ensure that your Mermaid data aligns with one of these supported layouts for successful diagram loading.
\ No newline at end of file
diff --git a/ej2-react/diagram/shapes.md b/ej2-react/diagram/shapes.md
index 152a6bed6..0478b49cd 100644
--- a/ej2-react/diagram/shapes.md
+++ b/ej2-react/diagram/shapes.md
@@ -1,30 +1,40 @@
---
layout: post
-title: Shapes in React Diagram component | Syncfusion®
-description: Learn here all about Shapes in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Shapes in React Diagram Component | Syncfusion®
+description: Learn to create and customize text, image, HTML, native, basic, path, and flow shapes in the Syncfusion React Diagram Component with examples.
control: Shapes
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Shapes in React Diagram component
+# Different Types of Shapes in React Diagram Component
-Diagram provides support to add different kind of nodes. They are as follows:
+The React Diagram component provides comprehensive support for adding various types of nodes to create rich, interactive diagrams. Shapes serve as the fundamental building blocks for representing data, processes, and visual elements in your diagrams.
-* Text node
-* Image node
-* HTML node
-* Native node
-* Basic shapes
-* Flow shapes
+This guide covers the following shape types and their implementation:
+
+* **Text nodes** - Display formatted text content.
+* **Image nodes** - Embed images from various sources.
+* **HTML nodes** - Include custom HTML elements.
+* **Native nodes** - Integrate SVG elements.
+* **Basic shapes** - Use predefined geometric shapes.
+* **Path shapes** - Create custom geometric paths.
+* **Flow shapes** - Represent process workflows.
-## Text
+## Text Nodes
+
+Text nodes enable you to add formatted text content directly to your diagram. They are ideal for labels, annotations, and textual information that enhances diagram readability.
+To create a text node, set the shape property to [`text`](https://ej2.syncfusion.com/react/documentation/api/diagram/node#shape) and define the content object with your desired text and styling options.
+
+<<<<<<< HEAD
Texts can be added to the diagram as [`text`](https://ej2.syncfusion.com/react/documentation/api/diagram/node/#shape) node. The shape property of the node allows you to set the type of node and for text nodes, it should be set as **text**. In addition, define the content object that is used to define the text to be added and style is used to customize the appearance of that text. The following code illustrates how to create a text node.
+=======
+>>>>>>> remotes/origin/development
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -37,11 +47,11 @@ Texts can be added to the diagram as [`text`](https://ej2.syncfusion.com/react/d
{% previewsample "page.domainurl/code-snippet/diagram/shapes/es5Text-cs1" %}
-## Image
+## Image Nodes
-Diagram allows to add images as [`image`](https://helpej2.syncfusion.com/react/documentation/api/diagram/node/#shape) nodes. The shape property of node allows you to set the type of node and for image nodes, it should be set as **image**. In addition, the source property of shape enables you to set the image source.
+Image nodes allow you to incorporate visual elements from various sources including URLs, local files, and Base64-encoded data. These nodes are perfect for adding logos, icons, or illustrative content to your diagrams.
-The following code illustrates how an image node is created.
+To create an image node, set the shape property to [`image`](https://helpej2.syncfusion.com/react/documentation/api/diagram/node/#shape) and specify the image source through the source property.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -54,9 +64,9 @@ The following code illustrates how an image node is created.
{% previewsample "page.domainurl/code-snippet/diagram/shapes/es5Image-cs1" %}
-### Base64 Encoded Image Into The Image Node:
+### Base64 Encoded Images
-The following code illustrates how to add Base64 image into image node.
+For scenarios where you need to embed images directly without external dependencies, use Base64-encoded image data. This approach ensures your diagrams remain self-contained and portable.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -69,17 +79,15 @@ The following code illustrates how to add Base64 image into image node.
{% previewsample "page.domainurl/code-snippet/diagram/shapes/es5Image-cs2" %}
-N> Deploy your HTML file in the web application and export the diagram (image node) or else the image node will not be exported in the Chrome and Firefox due to security issues. Refer to the following link.
+N> When deploying applications with image nodes, ensure your HTML files are served from a web server. Local file access restrictions in Chrome and Firefox may prevent image export functionality due to security policies. For more information, refer to browser-specific documentation on local image handling.
Link 1: `http://asked.online/draw-images-on-canvas-locally-using-chrome/2546077/`
Link 2: `http://stackoverflow.com/questions/4761711/local-image-in-canvas-in-chrome`
-### Image alignment
-
-Stretch and align the image content anywhere but within the node boundary.
+### Image Alignment and Scaling
-The scale property of the node allows to stretch the image as you desired (either to maintain proportion or to stretch). By default, the [`scale`](https://helpej2.syncfusion.com/react/documentation/api/diagram/image/#scale) property of the node is set as **meet**. The [`align`](https://helpej2.syncfusion.com/react/documentation/api/diagram/imageAlignment/) property is used to set the alignment of the image.
+Control how images appear within node boundaries using alignment and scaling properties. These features ensure your images display correctly regardless of node dimensions. The [`scale`](https://helpej2.syncfusion.com/react/documentation/api/diagram/image/#scale) property of the node is set as **meet**. The [`align`](https://helpej2.syncfusion.com/react/documentation/api/diagram/imageAlignment/) property controls positioning.
The following code illustrates how to use scale and align properties to stretch the image.
@@ -105,13 +113,15 @@ The following table illustrates all the possible scale options for the image nod
N> To visualize the changes in image scaling, it is Essential® to use the align property along with scale.
-## HTML
+## HTML Nodes
-Html elements can be embedded in the diagram through [`Html`](https://helpej2.syncfusion.com/react/documentation/api/diagram/node/#shape) type node. The shape property of node allows you to set the type of node and to create a HTML node it should be set as `HTML`.
+HTML nodes provide the flexibility to embed rich HTML content directly into your diagrams. This powerful feature enables you to create highly customized visual elements with advanced formatting, styling, and interactivity.
-N> HTML node cannot be exported to image format, like JPEG, PNG, and BMP. It is by design, while exporting the diagram is drawn in a canvas. Further, this canvas is exported into image formats. Currently, drawing in a canvas equivalent from all possible HTML is not feasible. Hence, this limitation.
+Set the shape property to [`Html`](https://helpej2.syncfusion.com/react/documentation/api/diagram/node/#shape) to create HTML nodes. You can define content using either inline templates or external node templates.
-### HTML Node with contentTemplate.
+N> HTML nodes cannot be exported to image formats (JPEG, PNG, BMP) due to canvas rendering limitations. This is by design, as converting arbitrary HTML content to canvas equivalents is not feasible for all HTML elements.
+
+### HTML Node with Content Template
To render an HTML node with a content template, we need to define the desired template string within the [`content`](../api/diagram/htmlModel/#content) property. The following code illustrates how to create an HTML node with a content template:
@@ -126,7 +136,7 @@ To render an HTML node with a content template, we need to define the desired te
{% previewsample "page.domainurl/code-snippet/diagram/shapes/es5ContentTemplate-cs1" %}
-#### Functional content template.
+#### Functional Content Template.
To render an HTML node using a functional template, we define a function that returns the template string. Within this function, modifications can be made based on the node's ID.
@@ -143,7 +153,7 @@ The following code illustrates how to render an HTML node using the function and
{% previewsample "page.domainurl/code-snippet/diagram/shapes/es5ContentFunctionalTemplate-cs1" %}
-### HTML Node With nodeTemplate
+### HTML Node With Node Template
To render html node with nodeTemplate we need to define the nodeTemplate in the html file and assign it to the [`nodeTemplate`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#nodetemplate) property of the diagram. The following code illustrates how to render html node with nodeTemplate.
@@ -158,7 +168,7 @@ To render html node with nodeTemplate we need to define the nodeTemplate in the
{% previewsample "page.domainurl/code-snippet/diagram/shapes/es5NodeTemplate-cs1" %}
-#### Functional nodeTemplate
+#### Functional NodeTemplate
We can define a function which returns a template string and assign it directly to the `nodeTemplate` property of diagram.
@@ -175,9 +185,11 @@ Refer the code example below.
{% previewsample "page.domainurl/code-snippet/diagram/shapes/es5NodeFunctionalTemplate-cs1" %}
-## Native
+## Native Nodes
+
+Native nodes allow you to embed SVG elements directly into your diagrams, providing scalable vector graphics with precise control over visual appearance. This approach is ideal for custom icons, complex shapes, and high-quality graphics that scale well at any size.
-Diagram provides support to embed SVG element into a node. The shape property of node allows you to set the type of node. To create a [`native`](https://helpej2.syncfusion.com/react/documentation/api/diagram/node/#shape) node, it should be set as **native**. The following code illustrates how a native node is created.
+To create a [`native`](https://helpej2.syncfusion.com/react/documentation/api/diagram/node/#shape) node, set the shape property to **native** and provide SVG content through the content property.
N> Like HTML node, the native node also cannot be exported to image format. Fill color of native node can be overridden by the inline style or fill of the SVG element specified in the template.
@@ -196,6 +208,7 @@ To render an Native node with a content template, we need to define the desired
{% previewsample "page.domainurl/code-snippet/diagram/shapes/es5Native-cs1" %}
+<<<<<<< HEAD
### Native node with node template
The [`nodeTemplate`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#nodetemplate) property allows defining reusable SVG templates at the diagram level. This approach is efficient when multiple nodes share similar vector graphics or when centralized template management is required.
@@ -210,12 +223,15 @@ The [`nodeTemplate`](https://helpej2.syncfusion.com/react/documentation/api/diag
{% endtabs %}
{% previewsample "page.domainurl/code-snippet/diagram/shapes/es5NodeTemplate-cs2" %}
+=======
+N> Similar to HTML nodes, native nodes cannot be exported to image formats due to canvas rendering limitations. Fill colors of native nodes can be overridden by inline SVG styles or fill attributes specified in the SVG template.
+>>>>>>> remotes/origin/development
-### SVG content alignment
+### SVG Content Alignment and Scaling
Stretch and align the svg content anywhere but within the node boundary.
-The scale property of the node allows to stretch the svg content as you desired (either to maintain proportion or to stretch). By default, the [`scale`](https://helpej2.syncfusion.com/react/documentation/api/diagram/nativeModel/#scale) property of native shape is set as **meet**.
+Control how SVG content appears within node boundaries using the same scaling principles as image nodes. The [`scale`](https://helpej2.syncfusion.com/react/documentation/api/diagram/nativeModel/#scale) property determines how SVG content fits within the node bounds.
The following tables illustrates all the possible scale options for the node.
@@ -226,11 +242,11 @@ The following tables illustrates all the possible scale options for the node.
| Slice |  |
| Stretch | |
-## Basic shapes
+## Basic Shapes
-* The [`Basic`](https://helpej2.syncfusion.com/react/documentation/api/diagram/node/#shape) shapes are common shapes that are used to represent the geometrical information visually. To create basic shapes, the type of the shape should be set as **basic**. Its shape property can be set with any one of the built-in shape.
+Basic shapes provide a comprehensive set of predefined geometric forms commonly used in diagrams, flowcharts, and technical drawings. These shapes offer consistency and quick deployment for standard diagram elements.
-* To render a rounded rectangle, you need to set the type as basic and shape as rectangle. Set the [`cornerRadius`](https://helpej2.syncfusion.com/react/documentation/api/diagram/basicShapeModel/#cornerradius) property to specify the radius of rounded rectangle.
+To create [`Basic`](https://helpej2.syncfusion.com/react/documentation/api/diagram/node/#shape) shapes, set the type property to **basic** and choose from the available built-in shapes. For rounded rectangles, use the [`cornerRadius`](https://helpej2.syncfusion.com/react/documentation/api/diagram/basicShapeModel/#cornerradius) property to specify the radius.
The following code example illustrates how to create a basic shape.
@@ -255,11 +271,12 @@ The list of basic shapes are as follows.

-## Path
+The basic shapes library includes rectangles, ellipses, triangles, polygons, stars, and many other geometric forms suitable for various diagramming needs.
-The [`Path`](https://helpej2.syncfusion.com/react/documentation/api/diagram/node/#shape) shape is a commonly used basic shape that allows visually to represent the geometrical information. As node path data, any geometrical data can be provided. You can create your own Geometry and assign it to data if you want anything different from the standard figures. A geometry does not require any dimension specifications, such as width or height, because it specifies its own size. If the node’s size is set, the geometry is extended to fit the node’s dimensions.
+## Path Shapes
-To create a path node, specify the shape as Path. The [`data`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pathModel/#data) property of node allows you to define the path to be drawn. The following code illustrates how a path node is created.
+Path shapes provide ultimate flexibility for creating custom geometric forms using SVG path data. This approach allows you to define any shape imaginable through precise path coordinates and commands.
+To create a [`Path`](https://helpej2.syncfusion.com/react/documentation/api/diagram/node/#shape) node, set the shape property to **path** and define the geometry through the [`data`](https://helpej2.syncfusion.com/react/documentation/api/diagram/pathModel/#data) property using standard SVG path syntax.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -274,7 +291,9 @@ To create a path node, specify the shape as Path. The [`data`](https://helpej2.s
## Flow Shapes
-The [`flow`](https://helpej2.syncfusion.com/react/documentation/api/diagram/node/#shape) shapes are used to represent the process flow. It is used for analyzing, designing, and managing for documentation process. To create a flow shape, specify the shape type as **flow**. Flow shapes and by default, it is considered as **process**. The following code example illustrates how to create a flow shape.
+Flow shapes are specialized elements designed for process modeling, workflow diagrams, and business process documentation. These standardized shapes follow common flowchart conventions and enhance diagram readability.
+
+To create [`flow`](https://helpej2.syncfusion.com/react/documentation/api/diagram/node/#shape) shapes, set the shape type to **flow** and specify the desired flow shape variant. The default flow shape is **process**.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -289,4 +308,4 @@ The [`flow`](https://helpej2.syncfusion.com/react/documentation/api/diagram/node
The list of flow shapes are as follows.
-
+
\ No newline at end of file
diff --git a/ej2-react/diagram/style.md b/ej2-react/diagram/style.md
index 130ac43aa..4a6012f82 100644
--- a/ej2-react/diagram/style.md
+++ b/ej2-react/diagram/style.md
@@ -1,18 +1,24 @@
---
layout: post
-title: Style in React Diagram component | Syncfusion®
-description: Learn here all about Style in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Style in React Diagram Component | Syncfusion®
+description: Learn here all about Style in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Style
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Style in React Diagram component
+# Style in React Diagram Component
-## Customizing the connector end point handle
+The React Diagram component provides extensive styling capabilities through CSS classes. This guide demonstrates how to customize various visual elements including connector handles, selection indicators, and interactive controls using CSS overrides.
-Use the following CSS to customize the connector end point handle.
+## Customizing Connector Endpoint Handles
+
+The connector endpoint handles are visual indicators that appear when hovering over or interacting with connector endpoints. These handles can be styled to match application themes or improve visibility.
+
+### Default Endpoint Handle Styling
+
+Use the following CSS to customize the connector endpoint handle appearance:
```scss
@@ -25,24 +31,22 @@ Use the following CSS to customize the connector end point handle.
```

-## Customizing the connector end point handle when connected
+### Connected Endpoint Handle Styling
-Use the following CSS to customize the connector end point handle when connected.
+When a connector endpoint is connected to a node or another connector, apply different styling to indicate the connected state:
```scss
-
.e-diagram-endpoint-handle.e-connected {
fill: red;
stroke: green;
stroke-width: 3px;
}
-
```

-## Customizing the connector end point handle when disabled
+### Disabled Endpoint Handle Styling
-Use the following CSS to customize the connector end point handle when disabled.
+For disabled connector endpoints, customize the appearance to clearly indicate the non-interactive state:
```scss
@@ -55,9 +59,13 @@ Use the following CSS to customize the connector end point handle when disabled.
```

-## Customizing the bezier segment thumb
+## Customizing Connector Segment Handles
-Use the following CSS to customize the bezier segment thumb.
+Connector segment handles allow users to manipulate different types of connector paths. Each connector type has specific handle styling options.
+
+### Bezier Segment Handles
+
+The Bezier segment handles control the curvature of Bezier connectors:
```scss
@@ -70,9 +78,9 @@ Use the following CSS to customize the bezier segment thumb.
```

-## Customizing the bezier control points
+### Bezier Control Point Handles
-Use the following CSS to customize the bezier control points.
+Control points define the curve shape of Bezier connectors and can be styled independently:
```scss
@@ -85,9 +93,9 @@ Use the following CSS to customize the bezier control points.
```

-## Customizing the orthogonal segment thumb
+### Orthogonal Segment Handles
-Use the following CSS to customize the orthogonal segment thumb.
+Orthogonal connectors use segment handles for adjusting right-angled path segments:
```scss
@@ -100,9 +108,9 @@ Use the following CSS to customize the orthogonal segment thumb.
```

-## Customizing the straight segment thumb
+### Straight Segment Handles
-Use the following CSS to customize the straight segment thumb.
+Straight connectors provide handles for direct path manipulation:
```scss
@@ -115,9 +123,13 @@ Use the following CSS to customize the straight segment thumb.
```

-## Customizing the resize handle
+## Customizing Selection and Manipulation Handles
+
+Selection handles and related controls provide visual feedback during object manipulation operations.
+
+### Resize Handles
-Use the following CSS to customize the resize handle.
+Resize handles appear on selected objects to enable size adjustments:
```scss
@@ -130,9 +142,9 @@ Use the following CSS to customize the resize handle.

-## Customizing the selector
+### Selection Indicator
-Use the following CSS to customize the selector.
+The selector outline indicates which objects are currently selected:
```scss
@@ -144,7 +156,7 @@ Use the following CSS to customize the selector.

-## Customizing the selector pivot line
+## Customizing the Selector Pivot Line
Use the following CSS to customize the line between the selector and rotate handle.
@@ -158,9 +170,9 @@ Use the following CSS to customize the line between the selector and rotate hand
```

-## Customizing the selector border
+### Selection Border
-Use the following CSS to customize the selector border.
+Customize the border that surrounds selected objects:
```scss
@@ -170,7 +182,7 @@ Use the following CSS to customize the selector border.
```
-## Customizing the rotate handle
+## Customizing the Rotate Handle
Use the following CSS to customize the rotate handle properties.
@@ -182,11 +194,16 @@ Use the following CSS to customize the rotate handle properties.
}
```
+

-## Customizing the symbolpalette while hovering
+## Customizing Symbol Palette Interactions
+
+The Symbol Palette provides drag-and-drop functionality with interactive states that can be styled.
-Use the following CSS to customize the symbolpalette while hovering.
+### Hover state styling
+
+Customize the appearance when hovering over symbols in the palette:
```scss
@@ -197,9 +214,9 @@ Use the following CSS to customize the symbolpalette while hovering.
```

-## Customizing the symbolpalette when selected
+### Selection state styling
-Use the following CSS to customize the symbolpalette when selected.
+Style the selected symbol appearance in the palette:
```scss
@@ -211,9 +228,13 @@ Use the following CSS to customize the symbolpalette when selected.

-## Customizing the ruler
+## Customizing Ruler Elements
+
+The ruler provides measurement guidance and can be styled to match the application design.
-Use the following CSS to customize the ruler properties.
+### Ruler Background and Text
+
+Customize the ruler's background color and font properties:
```scss
@@ -225,9 +246,9 @@ Use the following CSS to customize the ruler properties.
```

-## Customizing the ruler overlap
+### Ruler Overlap Area
-Use the following CSS to ruler overlap properties.
+The overlap area where horizontal and vertical rulers intersect can be styled separately:
```scss
@@ -238,9 +259,9 @@ Use the following CSS to ruler overlap properties.
```

-## Customizing the ruler marker color
+### Ruler Measurement Markers
-Use the following CSS to customize the marker color
+Customize the color and thickness of measurement markers on the ruler:
```scss
@@ -252,9 +273,13 @@ Use the following CSS to customize the marker color
```

-## Customizing the text edit
+## Customizing Text Editing Interface
+
+The text editing interface appears when editing text content within diagram objects.
-Use the following CSS to customize the text edit properties.
+### Text Edit Container
+
+Style the text editing container that appears during text input:
```scss
@@ -271,12 +296,11 @@ Use the following CSS to customize the text edit properties.
```
 
-## Customizing the text edit on selection
+### Text Selection Highlighting
-Use the following CSS to customize the text edit on selection properties.
+Customize the appearance of selected text within the editing interface:
```scss
-
.e-diagram-text-edit::selection {
background: yellow;
color: green;
@@ -285,9 +309,9 @@ Use the following CSS to customize the text edit on selection properties.
```

-## Customizing the page breaks
+## Customizing Page Break Indicators
-Use the following CSS to customize the page breaks line color
+Page break lines help visualize page boundaries when printing or exporting diagrams.
```scss
.e-diagram-page-break {
diff --git a/ej2-react/diagram/swim-lane.md b/ej2-react/diagram/swim-lane.md
index 684c78c66..867d69f79 100644
--- a/ej2-react/diagram/swim-lane.md
+++ b/ej2-react/diagram/swim-lane.md
@@ -1,24 +1,23 @@
---
layout: post
-title: Swim lane in React Diagram component | Syncfusion®
-description: Learn here all about Swim lane in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Swim lane in React Diagram Component | Syncfusion®
+description: Learn here all about Swim lane in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Swim lane
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Swim lane in React Diagram component
+# Swim lane in React Diagram Component
-A swimlane is a type of diagram node commonly used to visualize the relationship between a business process and the department responsible for it. It focuses on illustrating the logical connections between activities, making it simpler to grasp the dynamics of the process and the corresponding departmental responsibilities.
+Swimlanes are specialized diagram nodes that visualize business processes by organizing activities into distinct lanes or sections. Each lane typically represents a department, role, or responsibility area, making it easy to understand who is responsible for each step in a process. Swimlanes are particularly useful for workflow documentation, process mapping, and cross-functional process analysis.

-## Create a swimlane
+## Create a Swimlane
+To create a swimlane, set the node's shape type to [`swimlane`](https://ej2.syncfusion.com/react/documentation/api/diagram/swimLaneModel).Swimlanes are arranged horizontally by default and require proper configuration of headers and lanes to function correctly.
-To create a swimlane, the type of shape should be set as [`swimlane`](https://ej2.syncfusion.com/react/documentation/api/diagram/swimLaneModel).By default, swimlanes are arranged horizontally.
-
-The following code example illustrates how to define a swimlane object.
+The following code example demonstrates how to define a basic swimlane object:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -33,11 +32,31 @@ The following code example illustrates how to define a swimlane object.
N> When setting a Swimlane's ID, ensure that it does not contain white spaces, does not start with numbers or special characters, and does not include special characters like underscores (_) or spaces.
- N> When setting a Swimlane's ID, ensure that it does not contain white spaces, does not start with numbers or special characters, and does not include special characters like underscores (_) or spaces.
+## Orientation
+
+Swimlanes support two orientation modes to accommodate different layout requirements and design preferences.
+
+### Horizontal Orientation (default)
+Lanes are arranged from top to bottom, with the header positioned on the left side. This orientation works well for processes that flow from left to right.
+
+### Vertical Orientation
+Lanes are arranged from left to right, with the header positioned at the top. This orientation suits processes that flow from top to bottom.
+
+{% tabs %}
+{% highlight js tabtitle="index.jsx" %}
+{% include code-snippet/diagram/swimlane/es5SwimlaneOrientation-cs1/app/index.jsx %}
+{% endhighlight %}
+{% highlight ts tabtitle="index.tsx" %}
+{% include code-snippet/diagram/swimlane/es5SwimlaneOrientation-cs1/app/index.tsx %}
+{% endhighlight %}
+{% endtabs %}
+
+ {% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5SwimlaneOrientation-cs1" %}
+
## Headers
-Header was the primary element for swimlanes. The [`header`](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel) property of swimlane allows you to define its textual description and to customize its appearance.
+The header serves as the primary identifying element of a swimlane, providing a title or description for the entire swimlane container. The [`header`](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel) property allows customization of both content and appearance.
>Note: By using this header, the swimlane interaction will be performed, like selection, dragging,etc.
@@ -54,9 +73,9 @@ The following code example illustrates how to define a swimlane header.
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5Swimlaneheader-cs2" %}
-### Customization of headers
+### Header Customization
-The height and width of the swimlane header can be customized with [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel#height) properties of swimlane header. set fill color of header by using the [`style`](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel#style) property. The orientation of swimlane can be customized with the [`orientation`](https://ej2.syncfusion.com/react/documentation/api/diagram/swimLaneModel#header) property of the header.
+Swimlane headers can be extensively customized to match design requirements and improve visual clarity. The dimensions can be controlled using [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel#height) properties. Visual styling, including background color and text formatting, can be applied through the [`style`](https://ej2.syncfusion.com/react/documentation/api/diagram/headerModel#style) property. The swimlane's orientation can be controlled using the [`orientation`](https://ej2.syncfusion.com/react/documentation/api/diagram/swimLaneModel#header) property.
>Note: By default, the swimlane orientation is Horizontal.
@@ -73,9 +92,9 @@ The following code example illustrates how to customize the swimlane header.
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5HeaderCustomize-cs1" %}
-#### Dynamic customization of swimlane header
+### Dynamic Header Customization
-You can customize the swimlane header style and text properties dynamically. The following code illustrates how to dynamically customize the swimlane header.
+Headers can be modified programmatically during runtime to respond to user interactions or changing business requirements. This capability enables dynamic updating of swimlane titles, styling, and other properties based on application state or user input.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -88,27 +107,12 @@ You can customize the swimlane header style and text properties dynamically. The
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5Dynamicheader-cs1" %}
-### Header editing
+### Header Editing
Diagram provides the support to edit swimlane headers at runtime. We achieve the header editing by double click event. Double clicking the header label will enables the editing of that. The following image illustrates how to edit the swimlane header.
.
-## Orientation
-
-Swimlanes can be oriented in two ways: horizontally or vertically. This flexibility allows for versatile visualization of business processes and departmental relationships.
-The following code example illustrates how to define a swimlane with lane.
-
-{% tabs %}
-{% highlight js tabtitle="index.jsx" %}
-{% include code-snippet/diagram/swimlane/es5SwimlaneOrientation-cs1/app/index.jsx %}
-{% endhighlight %}
-{% highlight ts tabtitle="index.tsx" %}
-{% include code-snippet/diagram/swimlane/es5SwimlaneOrientation-cs1/app/index.tsx %}
-{% endhighlight %}
-{% endtabs %}
-
- {% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5SwimlaneOrientation-cs1" %}
## Limitations
diff --git a/ej2-react/diagram/swimlane-palette.md b/ej2-react/diagram/swimlane-palette.md
index 31dae0e7d..e0d991fe9 100644
--- a/ej2-react/diagram/swimlane-palette.md
+++ b/ej2-react/diagram/swimlane-palette.md
@@ -1,16 +1,20 @@
---
layout: post
-title: Swim lane in React Diagram component | Syncfusion®
-description: Learn here all about Swim lane in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Swim lane in React Diagram Component | Syncfusion®
+description: Learn how to add, configure, and customize swimlane shapes in the symbol palette of Syncfusion® React Diagram Component.
control: Swim lane in symbol palette
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-## Add swimlane to palette
+# Swimlane in Symbol Palette
-Diagram provides support to add swimlane and phases to symbol palette. The following code sample illustrate how to add swimlane and phases to palette.
+The React Diagram component provides comprehensive support for adding swimlane shapes and phases to the symbol palette. Swimlanes help organize process flows by grouping related activities into lanes, making complex diagrams more readable and structured.
+
+## Add Swimlane to Palette
+
+The diagram component supports adding both swimlane containers and individual phases to the symbol palette. This enables users to drag and drop pre-configured swimlane elements into their diagrams.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -23,10 +27,9 @@ Diagram provides support to add swimlane and phases to symbol palette. The follo
{% previewsample "page.domainurl/code-snippet/diagram/swimlane/es5Palette-cs1" %}
-### Drag and drop swimlane to palette
+### Drag and Drop Swimlane to Palette
* The drag and drop support for swimlane shapes has been provided.
* Horizontal lanes can be added to vertical swimlanes, and vice versa.
* The phase will only drop on swimlane shape with same orientation. The following image illustrates how to drag symbol from palette.
-
-
+
\ No newline at end of file
diff --git a/ej2-react/diagram/symbol-palette.md b/ej2-react/diagram/symbol-palette.md
index 3314c40e5..f9e914edb 100644
--- a/ej2-react/diagram/symbol-palette.md
+++ b/ej2-react/diagram/symbol-palette.md
@@ -1,12 +1,13 @@
---
layout: post
-title: Symbol palette in React Diagram component | Syncfusion®
-description: Learn here all about Symbol palette in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Symbol palette in React Diagram Component | Syncfusion®
+description: Learn here all about Symbol palette in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Symbol palette
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
+<<<<<<< HEAD
# Symbol palette in React Diagram component
@@ -15,6 +16,12 @@ The [`symbolPalette`](https://ej2.syncfusion.com/react/documentation/api/symbol
## Create symbol palette
The [`width`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#height) properties of the symbol palette allows to define the size of the symbol palette.
+=======
+# Symbol Palette in React Diagram Component
+The [`symbolPalette`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette) is a gallery of reusable symbols and diagram elements that can be dragged and dropped on the diagram surface multiple times. It provides an efficient way to organize and access frequently used nodes, connectors, and groups, streamlining the diagram creation process.
+## Create Symbol Palette
+The [`width`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#width) and [`height`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette#height) properties of the symbol palette allows to define the size of the symbol palette.
+>>>>>>> remotes/origin/development
```ts
import {
@@ -32,9 +39,7 @@ root.render();
```
-
-## Add nodes and palettes to SymbolPalette
-
+## Add Nodes and Palettes to SymbolPalette
The collection of predefined symbols can be added to palettes using the [`symbols`](https://ej2.syncfusion.com/react/documentation/api/diagram/paletteModel/#symbols) property.
A palette displays a group of related symbols and textually annotates the group with its header. A [`Palettes`](https://ej2.syncfusion.com/react/documentation/api/diagram/palette/) can be added as a collection of symbol groups.
@@ -55,7 +60,7 @@ The following code example illustrates how to define symbols in a palette and ho
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/palettes/es5palettes-cs1" %}
-## Add connectors in symbol palette
+## Add Connectors in Symbol Palette
Connectors can be added to the symbol palette by defining them in the symbols array of the palette.
The following example shows how to render connectors in the symbol palette:
@@ -72,9 +77,8 @@ The following example shows how to render connectors in the symbol palette:
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/palettes/palette-con" %}
-## Add group nodes in symbol palette
-
-The symbol palette supports adding group nodes. To add group nodes to the palette, the child nodes should be defined first, followed by the parent node. Refer to the following code to see how to render group nodes in the symbol palette:
+## Add Group Nodes in Symbol Palette
+The symbol palette supports adding group nodes. To add group nodes to the palette, define the child nodes first, followed by the parent node. Refer to the following code to see how to render group nodes in the symbol palette:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -89,6 +93,7 @@ The symbol palette supports adding group nodes. To add group nodes to the palett
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/palettes/palette-grp" %}
## Template-based symbols
+<<<<<<< HEAD
### HTML and SVG node with content template
@@ -112,14 +117,36 @@ Templates can be defined as strings and assigned to the node's `content` propert
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/palettes/palette-contentTemplate" %}
## Drag and drop symbols from palette to diagram
+=======
+>>>>>>> remotes/origin/development
-To drag and drop symbols from the palette to the diagram canvas, mousedown on the desired symbol in the palette, drag it to the desired location on the diagram canvas, and release the mouse button to drop it.
+### HTML and SVG node with content template
-
+The Symbol Palette supports the creation of complex nodes using HTML or SVG templates. This allows developers to incorporate rich, interactive, and visually engaging content within diagram elements.
+
+* For HTML content, set the node's `shape.type` property to **HTML**.
+* For SVG content, set the `shape.type` property to **Native**.
+
+Templates can be defined as strings and assigned to the node's `content` property.
+
+{% tabs %}
+{% highlight js tabtitle="index.jsx" %}
+{% include code-snippet/diagram/symbol-palette/palettes/palette-contentTemplate/app/index.jsx %}
+{% endhighlight %}
-## Add symbols to palette at runtime
+{% highlight ts tabtitle="index.tsx" %}
+{% include code-snippet/diagram/symbol-palette/palettes/palette-contentTemplate/app/index.tsx %}
+{% endhighlight %}
+{% endtabs %}
-Symbols can be added to palette at runtime by using public method, [`addPaletteItem`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#addpaletteitem). The following example shows how to add shapes to the palette at runtime.
+ {% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/palettes/palette-contentTemplate" %}
+
+## Drag and Drop Symbols from Palette to Diagram
+To drag and drop symbols from the palette to the diagram canvas, perform a mousedown action on the desired symbol in the palette, drag it to the desired location on the diagram canvas, and release the mouse button to drop it.
+
+## Runtime Palette Operations
+### Add Symbols to Palette at Runtime
+Symbols can be added to palette at runtime by using public method, [`addPaletteItem`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#addpaletteitem). The following example shows how to add shapes to the palette at runtime:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -133,9 +160,8 @@ Symbols can be added to palette at runtime by using public method, [`addPaletteI
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/palettes/symbol-add" %}
-## Remove symbols from palette at runtime
-
-Symbols can be removed from palette at runtime by using public method, [`removePaletteItem`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#removepaletteitem). The following example shows how to remove shapes from the palette at runtime.
+### Remove Symbols from Palette at Runtime
+Symbols can be removed from the palette at runtime using the public method [`removePaletteItem`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#removepaletteitem). The following example shows how to remove shapes from the palette at runtime.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -149,7 +175,7 @@ Symbols can be removed from palette at runtime by using public method, [`removeP
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/palettes/symbol-rmv" %}
-## Symbol defaults
+## Symbol Defaults
While adding more symbols such as nodes and connectors to the palette, you can define the default settings for those objects using the [`getNodeDefaults`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#getnodedefaults) and the [`getConnectorDefaults`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#getconnectordefaults) properties of symbol palette.
These properties allow you to specify default configurations for nodes and connectors, ensuring consistency and saving time when adding multiple symbols. By setting these properties, you can predefine attributes such as size, color, shape for nodes and line style, thickness, for connectors.
@@ -168,11 +194,9 @@ In the following example, the fill color of node and target decorator shape of c
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/palettes/es5defaultsettings-cs1" %}
-## Add palettes at runtime
-
-You can dynamically add palettes to the symbol palette at runtime to enhance flexibility and customization. This allows you to introduce new groups of symbols as needed without having to reload or reinitialize the diagram. The [`addPalettes`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#addpalettes)method of the symbol palette enables you to create and configure new palettes programmatically. This method takes parameters that define the palette's properties, such as the palette `ID`, `title`, and the `symbols` it contains.
-
-Follow the example below to see how to add a palette at runtime.
+### Add Palettes at Runtime
+You can dynamically add palettes to the symbol palette at runtime to enhance flexibility and customization. This allows you to introduce new groups of symbols as needed without having to reload or reinitialize the diagram. The [`addPalettes`](https://ej2.syncfusion.com/react/documentation/api/symbol-palette/#addpalettes) method of the symbol palette enables you to create and configure new palettes programmatically. This method takes parameters that define the palette's properties, such as the palette `ID`, `title`, and the `symbols` it contains.
+Follow the example below to see how to add a palette at runtime:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -186,7 +210,7 @@ Follow the example below to see how to add a palette at runtime.
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/palettes/palette-add" %}
-## Remove palettes at runtime
+## Remove Palettes at Runtime
You can remove palettes from the symbol palette at runtime. There are two ways to do this:
@@ -207,9 +231,11 @@ Follow the example below to see how to remove palettes at runtime.
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/palettes/palette-rmv" %}
-## Stretch the symbols into the palette
+## Stretch the Symbols into the Palette
-The [`fit`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolInfo/#fit) property defines whether the symbol has to be fit inside the size, that is defined by the symbol palette. For example, when you resize the rectangle in the symbol, ratio of the rectangle size has to be maintained rather changing into square shape. The following code example illustrates how to customize the symbol size.
+The [`fit`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolInfo/#fit) property determines whether a symbol should automatically scale to fit within the dimensions defined by the symbol palette.
+For example, if a symbol contains a rectangle and you resize it, enabling fit ensures that the rectangle maintains its aspect ratio rather than being distorted into a square.
+The following code example demonstrates how to customize symbol sizing using the fit property:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -223,7 +249,7 @@ The [`fit`](https://ej2.syncfusion.com/react/documentation/api/diagram/symbolInf
{% previewsample "page.domainurl/code-snippet/diagram/symbol-palette/palettes/es5fit-cs1" %}
-## Refresh symbol palette
+## Refresh Symbol Palette
The `refresh` method allows you to refresh the symbols dynamically in the SymbolPalette.
diff --git a/ej2-react/diagram/symmetric-layout.md b/ej2-react/diagram/symmetric-layout.md
index bf5eebc46..f2d7c4f25 100644
--- a/ej2-react/diagram/symmetric-layout.md
+++ b/ej2-react/diagram/symmetric-layout.md
@@ -1,24 +1,28 @@
---
layout: post
-title: Symmetric layout in React Diagram component | Syncfusion®
-description: Learn here all about Symmetric layout in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Symmetric layout in React Diagram Component | Syncfusion®
+description: Learn here all about Symmetric layout in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Symmetric layout
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Symmetric layout in React Diagram control
+# Symmetric Layout in React Diagram Component
-The symmetric layout has been formed using nodes position by closer together or pushing them further apart. This is repeated iteratively until the system comes to an equilibrium state.
+The symmetric layout is a force-directed algorithm that positions nodes by simulating physical forces between them. Nodes are repositioned iteratively by moving them closer together or pushing them further apart until the system reaches an equilibrium state, creating a balanced and visually appealing arrangement.
+## Understanding Symmetric Layout
-## Symmetric layout
+Symmetric layout works by applying spring-like forces between connected nodes and repulsion forces between all nodes. This creates a natural, organic layout where strongly connected components cluster together while maintaining proper spacing throughout the diagram.
+The layout’s [`springLength`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#springlength)property defines the ideal length that edges should maintain. This serves as the resting length for the springs connecting nodes.
-The layout’s [`springLength`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#springlength) defined as how long edges should be, ideally. This will be the resting length for the springs. Edge attraction and vertex repulsion forces to be defined by using layout’s [`springFactor`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#springfactor), the more sibling nodes repel each other. The relative positions do not change any more from one iteration to the next. The number of iterations can be specified by using layout’s [`maxIteration`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#maxiteration).
+Edge attraction and vertex repulsion forces are controlled using the layout's [`springFactor`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#springfactor)property. Higher values cause sibling nodes to repel each other more strongly, creating greater separation between unconnected elements.
-The following code illustrates how to arrange the nodes in a radial tree structure.
+The algorithm continues iterating until node positions stabilize and relative positions no longer change significantly between iterations. You can control the maximum number of iterations using the layout's [`maxIteration`](https://ej2.syncfusion.com/react/documentation/api/diagram/layout/#maxiteration).
+## Implementation
+The following code demonstrates how to arrange nodes using symmetric layout:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/tools.md b/ej2-react/diagram/tools.md
index a297168ee..e3c9bea8f 100644
--- a/ej2-react/diagram/tools.md
+++ b/ej2-react/diagram/tools.md
@@ -1,30 +1,34 @@
---
layout: post
-title: Tools in React Diagram component | Syncfusion®
-description: Learn here all about Tools in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Tools in React Diagram Component | Syncfusion®
+description: Learn how to use drawing tools, selection tools, and pan tools in Syncfusion® React Diagram Component for interactive diagram creation and navigation.
control: Tools
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Tools in React Diagram component
+# Tools in React Diagram Component
-The tools in the diagram control can perform various actions such as selecting, panning, and drawing. These tools are explained below.
+The React Diagram component provides a comprehensive set of interactive tools that enable users to create, modify, and navigate diagrams efficiently. These tools facilitate real-time interaction with diagram elements through mouse and keyboard operations.
-- `Select`: Allows you to choose specific elements within the diagram.
-- `Pan`: Enables you to move the view of the diagram to different areas without altering the elements.
-- `Draw`: Provides the ability to draw new shapes, connectors, on the diagram surface.
+## Overview
-These tools are Essential® for creating, editing, and navigating complex diagrams efficiently.
+The diagram control offers three primary tool categories:
-## Drawing tools
+- **Select**: Choose and manipulate specific elements within the diagram.
+- **Pan**: Navigate the diagram view to different areas without modifying elements.
+- **Draw**: Create new shapes, connectors, and freehand drawings on the diagram surface.
-Drawing tool allows you to draw any kind of node/connector during runtime by clicking and dragging on the diagram page.
+These tools are essential for building complex diagrams and provide the foundation for user interaction within the diagram environment.
-### Draw nodes
+## Drawing Tools
-To draw a shape, set the JSON of that shape to the [`drawingObject`](https://ej2.syncfusion.com/react/documentation/api/diagram/#drawingobject) property of the diagram and activate the drawing tool by using the [`tool`](https://ej2.syncfusion.com/react/documentation/api/diagram/#tool) property. The following code example illustrates how to draw a rectangle at runtime.
+Drawing tools enable real-time creation of diagram elements by clicking and dragging on the diagram canvas. All drawing operations are configured through the [`drawingObject`](https://ej2.syncfusion.com/react/documentation/api/diagram/#drawingobject) property and activated using the [`tool`](https://ej2.syncfusion.com/react/documentation/api/diagram/#tool) property.
+
+### Draw Nodes
+
+To draw shapes during runtime, configure the JSON representation of the desired shape in the `drawingObject` property and set the tool to drawing mode. The following example demonstrates how to draw a rectangle shape:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -37,7 +41,7 @@ To draw a shape, set the JSON of that shape to the [`drawingObject`](https://ej2
{% previewsample "page.domainurl/code-snippet/diagram/Tools/tools-cs1" %}
-The following code example illustrates how to draw a path shape.
+Path shapes can be drawn using the same approach with custom path data. The following example shows how to draw a path shape:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -52,7 +56,8 @@ The following code example illustrates how to draw a path shape.
### Text Nodes
-Similarly, you can draw a text node by setting the type of shape as 'Text' in the [`drawingObject`](https://ej2.syncfusion.com/react/documentation/api/diagram/#drawingobject) property. The [`text`](https://ej2.syncfusion.com/react/documentation/api/diagram/textModel/) type node contains a property called content, which specifies the text within the node. You can add the content to the text node once you finish drawing the node. Here is how you can draw a text node at runtime:
+Similarly, you can draw a text node by setting the type of shape as 'Text' in the `drawingObject` property. The [`text`](https://ej2.syncfusion.com/react/documentation/api/diagram/textModel/) node includes a content property that defines the displayed text. Users can add or modify the content after completing the drawing operation:
+
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -67,7 +72,8 @@ Similarly, you can draw a text node by setting the type of shape as 'Text' in th
### Draw Connectors
-To draw connectors, set the JSON of the connector to the drawType property. The drawing [`tool`](https://ej2.syncfusion.com/react/documentation/api/diagram/#tool) can be activated by using the tool property. The following code example illustrates how to draw a straight line connector.
+Connectors are drawn by defining the connector configuration in the `drawingObject` property. The drawing tool supports various connector types including straight, orthogonal, and bezier connectors:
+
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -80,13 +86,9 @@ To draw connectors, set the JSON of the connector to the drawType property. The
{% previewsample "page.domainurl/code-snippet/diagram/Tools/tools-cs4" %}
-### Polygon shape
+### Polygon Shapes
-The diagram allows you to create polygon shapes by clicking and moving the mouse at runtime on the diagram page. This interactive feature enables users to define custom shapes with multiple sides by specifying points directly on the diagram canvas.
-
-To draw a polygon shape, you need to set the [`drawingObject`](https://ej2.syncfusion.com/react/documentation/api/diagram/#drawingobject) property with the appropriate JSON configuration for a `polygon`. This includes specifying the type as 'Polygon'.
-
-The following code illustrates how to draw a polygon shape at runtime:
+The diagram supports interactive polygon creation through point-and-click interaction. Users can define custom shapes with multiple sides by specifying vertices directly on the diagram canvas. To enable polygon drawing, set the `drawingObject` type as **Polygon**:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -101,11 +103,9 @@ The following code illustrates how to draw a polygon shape at runtime:

-### Polyline Connector
-
-Diagram allows to create the polyline segments with straight lines and angled vertices at the control points by clicking and moving the mouse at runtime on the diagram page.
+### Polyline Connectors
-To draw a polyline connector, set the type of the [`drawingObject`](https://ej2.syncfusion.com/react/documentation/api/diagram/#drawingobject) as '`Polyline`'.
+Polyline connectors enable creation of multi-segment connections with straight lines and angled vertices. Users can interactively add control points by clicking on the diagram canvas. To draw polyline connectors, set the `drawingObject` type as **Polyline**:
The following code illustrates how to draw a polyline connector.
@@ -128,7 +128,7 @@ N> To make the segment thumb visible, inject the [`ConnectorEditing`](https://ej
### Freehand Drawing
-The diagram supports free-hand drawing, allowing users to draw anything independently on the diagram page. Free-hand drawing is enabled by setting the type of the [`drawingObject`](https://ej2.syncfusion.com/react/documentation/api/diagram/#drawingobject) property to '`Freehand`'.
+The diagram supports free-hand drawing, allowing users to draw anything independently on the diagram page. Free-hand drawing is enabled by setting the type of the `drawingObject` property to '`Freehand`'.
The following code illustrates how to perform freehand drawing:
@@ -147,31 +147,28 @@ The segments of a freehand connector can be adjusted at runtime by dragging the

-## Tool selection
+## Tool Selection and Precedence
-There are some functionalities that can be achieved by clicking and dragging on the diagram surface. They are as follows.
+The diagram supports multiple tool configurations that can be combined for different interaction scenarios. When multiple tools are enabled simultaneously, the system follows a specific precedence order to determine which tool takes priority:
-* Draw selection rectangle: MultipleSelect tool
-* Pan the diagram: Zoom pan
-* Draw nodes/connectors: DrawOnce/DrawOnce
+### Tool Precedence Hierarchy
-As all the three behaviors are completely different, you can achieve only one behavior at a time based on the tool that you choose.
-When more than one of those tools are applied, a tool is activated based on the precedence given in the following table.
+The following table shows the precedence order from highest to lowest priority:
-|Precedence|Tools|Description|
+|Precedence|Tool|Description|
|----------|-----|-----------|
-|1st|ContinuesDraw|Allows you to draw the nodes or connectors continuously. Once it is activated, you cannot perform any other interaction in the diagram.|
-|2nd|DrawOnce|Allows you to draw a single node or connector. Once you complete the DrawOnce action, SingleSelect, and MultipleSelect tools are automatically enabled.|
-|3rd|ZoomPan|Allows you to pan the diagram. When you enable both the SingleSelect and ZoomPan tools, you can perform the basic interaction as the cursor hovers node/connector. Panning is enabled when cursor hovers the diagram.|
-|4th|MultipleSelect|Allows you to select multiple nodes and connectors. When you enable both the MultipleSelect and ZoomPan tools, cursor hovers the diagram. When panning is enabled, you cannot select multiple nodes.|
-|5th|SingleSelect|Allows you to select individual nodes or connectors.|
-|6th|None|Disables all tools.|
+|1st|ContinuesDraw|Enables continuous drawing mode. Once activated, prevents all other interactions until deactivated.|
+|2nd|DrawOnce|Allows drawing a single element. After completion, automatically enables SingleSelect and MultipleSelect tools.|
+|3rd|ZoomPan|Enables diagram panning. When combined with SingleSelect, panning activates when cursor hovers over empty diagram areas.|
+|4th|MultipleSelect|Enables selection of multiple elements. When combined with ZoomPan, selection takes priority over panning when hovering over elements.|
+|5th|SingleSelect|Enables selection of individual elements.|
+|6th|None|Disables all interactive tools.|
These tools provide flexibility and functionality for creating and interacting with elements within the diagram interface.
-### Zoom pan tool
+### Zoom Pan Tool
-To activate panning mode set the [`tool`](https://ej2.syncfusion.com/react/documentation/api/diagram/#tool) property of the diagram as `ZoomPan`. The following code illustrates how to enable Zoom pan in the diagram
+The pan tool enables users to navigate large diagrams by dragging the view area. To activate panning mode, set the [`tool`](https://ej2.syncfusion.com/react/documentation/api/diagram/#tool) property to `ZoomPan`:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -188,7 +185,7 @@ N> Please note that panning the diagram is not possible when 'multiplePage' is s
## Events
-[`elementDraw`](https://ej2.syncfusion.com/react/documentation/api/diagram/#elementdraw) event is triggered when node or connector is drawn using drawing tool.
+The [`elementDraw`](https://ej2.syncfusion.com/react/documentation/api/diagram/#elementdraw) event triggers whenever users create nodes or connectors using drawing tools. This event provides access to the newly created element and enables custom logic during the drawing process:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/tooltip.md b/ej2-react/diagram/tooltip.md
index d20893070..8a1138d06 100644
--- a/ej2-react/diagram/tooltip.md
+++ b/ej2-react/diagram/tooltip.md
@@ -1,28 +1,34 @@
---
layout: post
-title: Tooltip in React Diagram component | Syncfusion®
-description: Learn here all about Tooltip in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Tooltip in React Diagram Component | Syncfusion®
+description: Learn here all about Tooltip in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Tooltip
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Tooltip in EJ2 React Diagram component
+# Tooltip in EJ2 React Diagram Component
-In a Graphical User Interface (GUI), a tooltip is a message that appears when the mouse hovers over an element. The diagram control provides tooltip support while dragging, resizing, rotating a node, and when the mouse hovers over any diagram element.
+In Graphical User Interface (GUI), a tooltip is a message that appears when the mouse hovers over an element. Tooltips enhance user experience by providing contextual information, guidance, and feedback without cluttering the interface. The diagram component provides comprehensive tooltip support while dragging, resizing, rotating nodes, and when the mouse hovers over any diagram element.
-## Default tooltip
+## Default Tooltip
-By default, the diagram displays a tooltip showing size, position, and angle information while dragging, resizing, or rotating a node. The following images illustrate how the diagram displays node information during these interactions.
+By default, the diagram displays a tooltip showing size, position, and angle information while dragging, resizing, or rotating a node. This provides real-time feedback during interactive operations:
+
+- **Drag**: Shows current X and Y coordinates of the node.
+- **Resize**: Displays current width and height dimensions.
+- **Rotate**: Indicates the current rotation angle in degrees.
+
+The following images illustrate how the diagram displays node information during these interactions.
| Drag | Resize | Rotate |
|---|---|---|
|  |  |  |
-### Disable default tooltip
+### Disable Default Tooltip
The default tooltip that appears while interacting with nodes can be disabled by removing the tooltip constraints from the [`selectorConstraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/selectorConstraints/) of the [`selectedItems`](https://helpej2.syncfusion.com/react/documentation/api/diagram/selectorModel/) property of the diagram.
@@ -37,7 +43,7 @@ The default tooltip that appears while interacting with nodes can be disabled by
{% previewsample "page.domainurl/code-snippet/diagram/tooltip/es5tooltip-cs1" %}
-## Tooltip for a specific node/connector
+## Tooltip for a Specific Node/Connector
The tooltip can be customized for each node and connector. Remove the **InheritTooltip** option from the [`constraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/#constraints) of that node/connector. The following code example illustrates how to customize the tooltip for individual elements.
@@ -52,7 +58,7 @@ The tooltip can be customized for each node and connector. Remove the **InheritT
{% previewsample "page.domainurl/code-snippet/diagram/tooltip/es5TooltipNodes-cs1" %}
-## Inherit diagram tooltip
+## Inherit Diagram Tooltip
The diagram supports inheriting the diagram tooltip when the mouse hovers over any node or connector. To show a tooltip on mouse over, set the diagram's [`tooltip`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#tooltip) property with the tooltip [`content`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#content) and [`position`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#position). Ensure that the nodes and connectors have their constraints set to **InheritTooltip**, as shown in the following example.
@@ -67,9 +73,9 @@ The diagram supports inheriting the diagram tooltip when the mouse hovers over a
{% previewsample "page.domainurl/code-snippet/diagram/tooltip/es5InheritTooltip-cs1" %}
-### Disable tooltip at runtime
+### Disable Tooltip at Runtime
-The tooltip on mouse over can be disabled by setting the diagram's [`tooltip`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#tooltip) property to `null`. The following code example illustrates how to disable the mouse over tooltip at runtime.
+The tooltip on mouse over can be disabled by assigning the diagram's `tooltip` property as **null**. The following code example illustrates how to disable the mouse over tooltip at runtime.
```ts
@@ -87,7 +93,7 @@ The tooltip on mouse over can be disabled by setting the diagram's [`tooltip`](h
The tooltip feature has been implemented to support Ports, providing the ability to display information or descriptions when the mouse hovers over them.
-To display tooltips on mouseover, set the desired tooltip [`content`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#content) by utilizing the [`tooltip`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#tooltip) property.
+To display tooltips on mouseover, set the desired tooltip [`content`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#content) by utilizing the `tooltip` property.
Tooltips for Ports can be enabled or disabled using the [`PortConstraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/port/#constraints) Tooltip property.
@@ -131,7 +137,7 @@ The following image illustrates how the diagram displays tooltips during an inte

-## Tooltip template content
+## Tooltip Template Content
The tooltip template content allows you to customize the tooltip by using HTML templates. This means you can define the structure and style of the tooltip using HTML, providing greater flexibility and control over its appearance. By leveraging HTML templates, you can include rich content such as formatted text, images, and other HTML elements within the tooltip, enhancing the user experience with more informative and visually appealing tooltips.
@@ -148,11 +154,11 @@ The following code example illustrates how to add formatted HTML content to the
{% previewsample "page.domainurl/code-snippet/diagram/tooltip/es5TooltipTemplate-cs1" %}
-## Tooltip alignments
+## Tooltip Alignments
-### Tooltip relative to object
+### Tooltip Relative to Object
-The diagram supports displaying a tooltip around the node or connector that is hovered over by the mouse. The tooltip's alignment can be adjusted using the [`position`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#position) property. The [`relativeMode`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#relativemode) property specifies whether the tooltip should be displayed around the object or at the mouse position.
+The diagram provides support to show tooltip around the node/connector that is hovered by the mouse. The tooltip can be aligned by using the [`position`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#position) property. The [`relativeMode`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#relativemode) property of the tooltip defines whether the tooltip has to be displayed around the object or at the mouse position.
The following code example illustrates how to position the tooltip around object.
@@ -167,9 +173,9 @@ The following code example illustrates how to position the tooltip around object
{% previewsample "page.domainurl/code-snippet/diagram/tooltip/es5TooltipObject-cs1" %}
-### Tooltip relative to mouse position
+### Tooltip Relative to Mouse Position
-To display the tooltip at the mouse position, set the **mouse** option in the [`relativeMode`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#relativemode) property of the tooltip.
+To display the tooltip at the mouse position, set the **mouse** option in the `relativeMode` property of the tooltip.
The following code example illustrates how to show tooltip at mouse position.
@@ -184,9 +190,9 @@ The following code example illustrates how to show tooltip at mouse position.
{% previewsample "page.domainurl/code-snippet/diagram/tooltip/es5TooltipMouse-cs1" %}
-## Tooltip animation
+## Tooltip Animation
-To animate the tooltip, you can use a range of animation effects controlled by the [`animation`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#animation) property. This property allows you to customize the delay, duration, and various other effects according to your preferences.
+To animate the tooltip, a set of specific animation effects are available, and it can be controlled by using the [`animation`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#animation) property. The animation property also allows you to set delay, duration, and various other effects of your choice.
Refer the following sample where we used zoomIn animation for tooltip open and zoomOut animation for tooltip close with delay and duration.
@@ -201,7 +207,7 @@ Refer the following sample where we used zoomIn animation for tooltip open and z
{% previewsample "page.domainurl/code-snippet/diagram/tooltip/es5TooltipAnimation-cs1" %}
-## Sticky tooltip
+## Sticky Tooltip
A sticky tooltip will remain visible even after you move the mouse away from the node or connector. You can activate this feature by setting the [`isSticky`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#issticky) property of the tooltip.
@@ -218,9 +224,9 @@ The following example shows how to render sticky tooltip.
{% previewsample "page.domainurl/code-snippet/diagram/tooltip/es5stickyTooltip-cs1" %}
-## Hide tooltip pointer
+## Hide Tooltip Pointer
-The [`showTipPointer`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#showtippointer) property allows to control the visibility of tooltip pointer. By default, the `showTipPointer` is set as true.
+The [`showTipPointer`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#showtippointer) property allows to control the visibility of tooltip pointer. By default, the `showTipPointer` is set as **true**.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -233,7 +239,7 @@ The [`showTipPointer`](https://helpej2.syncfusion.com/react/documentation/api/di
{% previewsample "page.domainurl/code-snippet/diagram/tooltip/es5hideTooltip-cs1" %}
-## Tooltip size
+## Tooltip Size
By default, the size of the tooltip is calculated based on its content. If you want to customize the size, you can use the [`width`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#width) and [`height`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramTooltip/#height) properties of the tooltip.
@@ -250,7 +256,7 @@ The following code example shows how to set the size for the tooltip:
{% previewsample "page.domainurl/code-snippet/diagram/tooltip/es5ToolTipSize-cs1" %}
-## Show/Hide tooltip at runtime
+## Show/Hide Tooltip at Runtime
You can show or hide the tooltip dynamically using a button click with the [`showTooltip`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#showtooltip) and [`hideTooltip`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#hidetooltip) methods of the diagram. This allows you to control the tooltip visibility programmatically rather than relying on user hover actions. In some cases, you may want to display the tooltip without requiring the user to hover over the object.
@@ -270,8 +276,8 @@ The following example demonstrates how to show or hide the tooltip at runtime:
## Tooltip for Annotation
Tooltips can be added to annotations to display additional information on mouseover.
-To display tooltips on mouseover, set the desired tooltip text to the [`tooltip`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#tooltip) property of the annotation.
-Tooltips for Annotations can be enabled or disabled by setting the [`AnnotationConstraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationConstraints/) property as [`Tooltip`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#tooltip).
+To display tooltips on mouseover, set the desired tooltip text to the `tooltip` property of the annotation.
+Tooltips for Annotations can be enabled or disabled by setting the [`AnnotationConstraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/annotationConstraints/) property as `Tooltip`.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/umldiagram.md b/ej2-react/diagram/umldiagram.md
index a106f3bf9..c789db70a 100644
--- a/ej2-react/diagram/umldiagram.md
+++ b/ej2-react/diagram/umldiagram.md
@@ -1,20 +1,22 @@
---
layout: post
-title: Umldiagram in React Diagram component | Syncfusion®
-description: Learn here all about Umldiagram in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Umldiagram in React Diagram Component | Syncfusion®
+description: Learn how to create and customize UML Class and Activity diagrams in Syncfusion® React Diagram Component with comprehensive examples and API references.
control: Umldiagram
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# UML diagram in React Diagram component
+# UML Diagrams in React Diagram Component
+
+This guide demonstrates how to create and customize UML (Unified Modeling Language) diagrams using the Syncfusion React Diagram component. You'll learn to build UML Class diagrams for object-oriented system modeling and UML Activity diagrams for workflow visualization.
## UML Class Diagram
-A class diagram visually depicts the static structure of an application and is extensively employed in modeling object-oriented systems. It holds a unique position in UML diagrams, as it directly aligns with object-oriented languages. The diagram also facilitates the automatic generation of class diagram shapes based on business logic, streamlining the translation from conceptual models to practical implementation.
+A class diagram visually depicts the static structure of an application and is extensively employed in modeling object-oriented systems. It holds a unique position in UML diagrams, as it directly aligns with object-oriented languages. The diagram also facilitates automatic generation of class diagram shapes based on business logic, streamlining the translation from conceptual models to practical implementation.
-## Uml Class Diagram Shapes
+## UML Class Diagram Shapes
The UML class diagram shapes are explained as follows.
@@ -45,9 +47,9 @@ The UML class diagram shapes are explained as follows.
### Interface
-An [`interface`](https://ej2.syncfusion.com/react/documentation/api/diagram/umlClassifierShapeModel#interface) is a specific type of classifier that signifies a declaration of a cohesive set of public features and obligations. When creating an interface, involves defining the classifier property using the notation. This foundational concept in object-oriented programming outlines a contract for classes to adhere to, specifying the required methods and behaviors without delving into the implementation details.
+An [`interface`](https://ej2.syncfusion.com/react/documentation/api/diagram/umlClassifierShapeModel#interface) is a specific type of classifier that represents a declaration of a cohesive set of public features and obligations. When creating an interface, define the classifier property using the interface notation. This concept in object-oriented programming outlines a contract for classes to implement, specifying the required methods and behaviors without providing implementation details.
-Additionally, you can define the [`name`](https://ej2.syncfusion.com/react/documentation/api/diagram/umlInterfaceModel#name), [`attributes`](https://ej2.syncfusion.com/react/documentation/api/diagram/umlInterfaceModel#attributes), and [`methods`](https://ej2.syncfusion.com/react/documentation/api/diagram/umlInterfaceModel#methods) of the interface using the interface property of the node.
+Additionally, you can define the `name`, `attributes`, and `methods` of the interface using the interface property of the node.
The attributes' name, type, and scope properties allow you to specify the name, data type, and visibility of each attribute.
@@ -70,9 +72,9 @@ The following code example illustrates how to create an interface:
### Enumeration
-To establish an enumeration, designate the classifier property of the node as [enumeration](https://ej2.syncfusion.com/react/documentation/api/diagram/umlClassifierShapeModel#enumeration). Additionally, define the [`name`](https://ej2.syncfusion.com/react/documentation/api/diagram/umlEnumerationModel/#name) and enumerate the [`members`](https://ej2.syncfusion.com/react/documentation/api/diagram/umlEnumerationMemberModel/) of the enumeration using the appropriate enumeration property of the node. This process encapsulates a set of distinct values within the enumeration, allowing for a clear representation of specific,and named constants within a system.
+To establish an enumeration, designate the classifier property of the node as [enumeration](https://ej2.syncfusion.com/react/documentation/api/diagram/umlClassifierShapeModel#enumeration). Additionally, define the `name` and enumerate the [`members`](https://ej2.syncfusion.com/react/documentation/api/diagram/umlEnumerationMemberModel/) of the enumeration using the appropriate enumeration property of the node. This process encapsulates a set of distinct values within the enumeration, allowing for a clear representation of specific,and named constants within a system.
-You can set a name for the enumeration members collection using the [`name`](https://ej2.syncfusion.com/react/documentation/api/diagram/umlEnumerationModel/#name) property of members collection.
+You can set a name for the enumeration members collection using the `name` property of members collection.
The following code example illustrates how to create an enumeration.
@@ -89,7 +91,7 @@ The following code example illustrates how to create an enumeration.
## UML Class Relationships
-* A class may be involved in one or more relationships with other classes. A relationship can be one of the following types:
+A class may be involved in one or more relationships with other classes. The relationship types available are as follows:
| Shape | Image |
| ----------- | ------------------------------------ |
@@ -106,7 +108,7 @@ The following code example illustrates how to create an enumeration.
1.Directional
2.BiDirectional
-The association property allows you to define the type of association. The default value of association is `“Directional”`. The following code example illustrates how to create an association.
+The association property allows you to define the type of association. The default value of association is **Directional**. The following code example illustrates how to create an association.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -138,7 +140,7 @@ The following code example illustrates how to create an aggregation.
### Composition
-Composition is a strong form of `aggregation`. The composition is decorated with a black diamond. To create a composition shape, define the [`relationship`](https://ej2.syncfusion.com/react/documentation/api/diagram/relationShipModel/#relationship) property of the connector as “Composition”.
+Composition is a strong form of `aggregation`. The composition is decorated with a black diamond. To create a composition shape, define the `relationship` property of the connector as “Composition”.
The following code example illustrates how to create a composition.
@@ -157,7 +159,7 @@ The following code example illustrates how to create a composition.
Inheritance is also called a “generalization”. Inheritance is a binary taxonomic directed relationship between a more general classifier (superclass) and a more specific classifier (subclass).Inheritance is shown as a line with a hollow triangle.
-To create an inheritance, define the [`relationship`](https://ej2.syncfusion.com/react/documentation/api/diagram/relationShipModel/#relationship) as “inheritance”.
+To create an inheritance, define the `relationship` as “inheritance”.
The following code example illustrates how to create an inheritance.
@@ -174,7 +176,7 @@ The following code example illustrates how to create an inheritance.
### Dependency
-Dependency is a directed relationship, which is used to show that some UML elements need or depend on other model elements for specifications. Dependency is shown a dashed line with an opened arrow. To create a dependency, define the [`relationship`](https://ej2.syncfusion.com/react/documentation/api/diagram/relationShipModel/#relationship) property of the connector as “dependency”.
+Dependency is a directed relationship, which is used to show that some UML elements need or depend on other model elements for specifications. Dependency is shown a dashed line with an opened arrow. To create a dependency, define the `relationship` property of the connector as “dependency”.
The following code example illustrates how to create a dependency.
@@ -193,22 +195,22 @@ The following code example illustrates how to create a dependency.
### Multiplicity
-Multiplicity is a definition of an inclusive interval of non-negative integers to specify the allowable number of instances of a described element. The type of multiplicity are as follows.
+Multiplicity defines an inclusive interval of non-negative integers to specify the allowable number of instances of the described element. The types of multiplicity are as follows:
- 1.OneToOne
- 2.ManyToOne
- 3.OneToMany
- 4.ManyToMany
+1. OneToOne
+2. ManyToOne
+3. OneToMany
+4. ManyToMany
-By default the multiplicity will be considered as “OneToOne”.
+By default, the multiplicity is considered as **OneToOne**.
-The multiplicity property in UML allows you to specify large number of elements or some collection of elements.
+The multiplicity property in UML allows you to specify a large number of elements or some collection of elements.
-The shape multiplicity’s [`source`](https://ej2.syncfusion.com/react/documentation/api/diagram/classifierMultiplicityModel/#source) property is used to set the source label to the connector and the [`target`](https://ej2.syncfusion.com/react/documentation/api/diagram/classifierMultiplicityModel/#target) property is used to set the target label to the connector.
+The shape multiplicity’s [`source`](https://ej2.syncfusion.com/react/documentation/api/diagram/classifierMultiplicityModel/#source) property sets the source label to the connector and the [`target`](https://ej2.syncfusion.com/react/documentation/api/diagram/classifierMultiplicityModel/#target) property is used to set the target label to the connector.
To set an optionality or cardinality for the connector source label, use the optional property.
-The [`lowerBounds`](https://ej2.syncfusion.com/react/documentation/api/diagram/multiplicityLabelModel#lowerBounds) and [`upperBounds`](https://ej2.syncfusion.com/react/documentation/api/diagram/multiplicityLabelModel#upperBounds) could be natural constants or constant expressions evaluated to a natural (non negative) number. The upper bound could also be specified as an asterisk ‘\*’ which denotes an unlimited number of elements. The upper bound should be greater than or equal to the lower bound.
+The [`lowerBounds`](https://ej2.syncfusion.com/react/documentation/api/diagram/multiplicityLabelModel#lowerBounds) and [`upperBounds`](https://ej2.syncfusion.com/react/documentation/api/diagram/multiplicityLabelModel#upperBounds) can be natural constants or constant expressions evaluated to natural (non-negative) numbers. Upper bound can also be specified as asterisk '*' which denotes unlimited number of elements. Upper bound should be greater than or equal to the lower bound.
The following code example illustrates how to customize the multiplicity.
@@ -223,11 +225,11 @@ The following code example illustrates how to customize the multiplicity.
{% previewsample "page.domainurl/code-snippet/diagram/umldiagramshapes/es5multiplicity-cs1" %}
-## How to add UML child at runtime
+## How to Add UML Child at Runtime
In UML nodes, child elements such as members, methods and attributes can be added either programmatically or interactively.
-### Adding UML child through code
+### Adding UML Child Through Code
The [addChildToUmlNode](https://ej2.syncfusion.com/react/documentation/api/diagram#addchildtoumlnode) method is employed for dynamically adding a child to the UML node during runtime, providing flexibility in modifying the diagram structure programmatically.
@@ -244,15 +246,15 @@ The following code example illustrates how to add members, methods and attribute
{% previewsample "page.domainurl/code-snippet/diagram/umldiagramshapes/es5Method-cs1" %}
-### Adding UML child through user interaction
+### Adding UML Child Through User Interaction
To include a child, select a node, move the mouse outside it, and position the pointer near the right side. A highlighter emerges between the two child elements. Click the highlighter to add a child type to the chosen UML node seamlessly. The following gif illustrates how to add a Child through user interaction.

-## Adding UML Nodes in Symbol palette
+## Adding UML Nodes in Symbol Palette
-UML built-in shapes are efficiently rendered in a symbol palette. The [`symbols`](https://ej2.syncfusion.com/react/documentation/api/diagram/paletteModel/#symbols) property of [`palettes`](https://ej2.syncfusion.com/react/documentation/api/diagram/paletteModel/) is used to define UML symbols with the necessary classes and methods. By incorporating this feature, you can seamlessly augment the palette with a curated collection of predefined UML symbols, thereby enhancing the versatility of your UML diagramming application.
+UML built-in shapes are efficiently rendered in a symbol palette. The [`symbols`](https://ej2.syncfusion.com/react/documentation/api/diagram/paletteModel/#symbols) property of [`palettes`](https://ej2.syncfusion.com/react/documentation/api/diagram/paletteModel/) is used to define UML symbols with the necessary classes and methods. This feature allows you to add a collection of predefined UML symbols to the palette, making your UML diagramming application more versatile.
The following code example showcases the rendering of UML built-in shapes in a symbol palette.
@@ -267,7 +269,7 @@ The following code example showcases the rendering of UML built-in shapes in a s
{% previewsample "page.domainurl/code-snippet/diagram/umldiagramshapes/es5preview-cs4" %}
-## Editing in UML nodes
+## Editing in UML Nodes
You can edit the name, attributes, and methods of the class diagram shapes just double clicking, similar to editing a node annotation.
@@ -275,7 +277,7 @@ The following image illustrates how the text editor looks in an edit mode.

-## UML Activity diagram
+## UML Activity Diagram
An Activity diagram functions as a visual flowchart, illustrating the progression from one activity to the next within a system. Each activity corresponds to a system operation, providing a clear depiction of the sequential flow in a dynamic process..
@@ -287,9 +289,9 @@ The purpose of an activity diagram can be described as follows.
3. Describe the parallel, branched, and concurrent flow of the system.
-### UML Activity diagram Shapes
+### UML Activity Diagram Shapes
-To create a UmlActivity, define the [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/umlActivityShapeModel/#type) as "UmlActivity" and set the list of built-in shapes in the [`shape`](https://ej2.syncfusion.com/react/documentation/api/diagram/umlActivityShapeModel/#shape) property as demonstrated below.
+To create a UmlActivity, define the `type` as "UmlActivity" and set the list of built-in shapes in the `shape` property as demonstrated below.
| Shape | Image |
| -------------- | ---------------------------------------- |
@@ -320,9 +322,9 @@ The following code illustrates how to create a UmlActivity shapes.
{% previewsample "page.domainurl/code-snippet/diagram/umldiagramshapes/es5UmlActivity-cs1" %}
-### Uml Activity connector
+### UML Activity Connector
-To establish a UML Activity connector, specify the [`type`](https://ej2.syncfusion.com/react/documentation/api/diagram/relationShipModel/#type) of connector shape as "UmlActivity" and define the flow as either "Exception," "Control," or "Object." This configuration delineates the nature of the connection, allowing for a precise representation of the interaction within the activity diagram.
+To establish a UML Activity connector, specify the `type` of connector shape as "UmlActivity" and define the flow as either "Exception," "Control," or "Object." This configuration delineates the nature of the connection, allowing for a precise representation of the interaction within the activity diagram.
The following code illustrates how to create a UmlActivity connector.
diff --git a/ej2-react/diagram/umlsequencediagram.md b/ej2-react/diagram/umlsequencediagram.md
index 2f53711f0..3126716b5 100644
--- a/ej2-react/diagram/umlsequencediagram.md
+++ b/ej2-react/diagram/umlsequencediagram.md
@@ -1,36 +1,45 @@
---
layout: post
-title: UmlSequenceDiagram in React Diagram component | Syncfusion®
-description: Learn here all about UmlSequenceDiagram in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: UmlSequenceDiagram in React Diagram Component | Syncfusion®
+description: Learn how to create and customize UML sequence diagrams in Syncfusion® React Diagram Component with participants, messages, activation boxes, and fragments.
control: UmlSequenceDiagram
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# UML Sequence Diagram in React Diagram component
+# UML Sequence Diagram in React Diagram Component
+A UML sequence diagram is a type of interaction diagram that visualizes how objects communicate with each other over time. These diagrams show the sequence of messages exchanged between participants, making them essential for understanding system interactions, API workflows, and process flows.
-A UML sequence diagram is an interaction diagram that demonstrates how objects interact with each other and the order of these interactions. The Syncfusion® diagram control provides comprehensive support for creating and visualizing UML sequence diagrams through the [UmlSequenceDiagramModel](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceDiagramModel/). To enable this functionality, assign the `UmlSequenceDiagramModel` to the [model](https://ej2.syncfusion.com/react/documentation/api/diagram/#model) property of the diagram control.
+The Syncfusion® React Diagram component provides comprehensive support for creating and visualizing UML sequence diagrams through the [`UmlSequenceDiagramModel`](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceDiagramModel/). This specialized model enables the creation of sequence diagrams with proper UML notation and automated layout capabilities.
## UML Sequence Diagram Elements
-A sequence diagram includes several key elements such as participants, messages, activation boxes, and fragments. The sections below demonstrate how to define and configure these components using the diagram control.
+A sequence diagram comprises several essential elements that work together to represent system interactions. The following sections demonstrate how to define and configure these components.
### Participants
-[UmlSequenceParticipantModel](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceParticipantModel/) in a sequence diagram represent the entities that interact with each other, appearing at the top of the diagram with lifelines extending vertically downward.
+[`UmlSequenceParticipantModel`](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceParticipantModel/) represents the entities that participate in the interaction sequence. Participants appear as rectangular boxes at the top of the diagram, with lifelines extending vertically downward to show their existence throughout the interaction timeline.
+
+#### Participant Types
+
+Participants can be displayed in two forms:
+- **Actors**: Human users or external systems (displayed with stick figure notation).
+- **Objects**: System components, classes, or services (displayed as rectangular boxes).
#### UmlSequenceParticipantModel Properties
| Property | Type | Description |
|---|---|---|
-| id | string \| number | A unique identifier for the participant |
-| content | string | The display text for the participant |
-| isActor | boolean | Specifies whether the participant is displayed as an actor (true) or an object (false) |
-| showDestructionMarker | boolean | Indicates whether a destruction marker (X) is shown at the end of the lifeline |
-| activationBoxes | UmlSequenceActivationBoxModel[] | A collection of activation boxes associated with the participant |
+| id | string \| number | A unique identifier for the participant. |
+| content | string | The display text for the participant.. |
+| isActor | boolean | Specifies whether the participant is displayed as an actor (true) or an object (false). |
+| showDestructionMarker | boolean | Indicates whether a destruction marker (X) is shown at the end of the lifeline. |
+| activationBoxes | UmlSequenceActivationBoxModel[] | A collection of activation boxes associated with the participant .|
+
+#### Creating Participants
-The following code example illustrates how to create participants:
+The following code example demonstrates how to create different types of participants:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -45,9 +54,11 @@ The following code example illustrates how to create participants:
### Messages
-[UmlSequenceMessageModel](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceMessageModel/) represents communication between participants and are displayed as arrows connecting lifelines.
+[`UmlSequenceMessageModel`](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceMessageModel/) represents communication between participants . Messages are displayed as arrows connecting lifelines and indicate the flow of information or requests between system components.
-#### Types of Messages
+#### Message Types and Usage
+
+Different message types serve specific purposes in sequence diagrams:
| Message Type | Description | Example |
|---|---|---|
@@ -62,13 +73,15 @@ The following code example illustrates how to create participants:
| Property | Type | Description |
|---|---|---|
-| id | string \| number | A unique identifier for the message |
-| content | string | The display text for the message |
-| fromParticipantID | string \| number | ID of the participant sending the message |
+| id | string \| number | A unique identifier for the message. |
+| content | string | The display text for the message. |
+| fromParticipantID | string \| number | ID of the participant sending the message.. |
| toParticipantID | string \| number | ID of the participant receiving the message |
-| type | UmlSequenceMessageType | Type of the message (Synchronous, Asynchronous, Reply, Create, Delete, Self) |
+| type | UmlSequenceMessageType | Type of the message (Synchronous, Asynchronous, Reply, Create, Delete, Self). |
+
+#### Creating Messages
-The following code example illustrates how to create messages:
+The following example shows how to create different types of messages between participants:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -83,17 +96,19 @@ The following code example illustrates how to create messages:
### Activation Boxes
-[UmlSequenceActivationBoxModel](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceActivationBoxModel/) represents periods when a participant is active and processing a message. They appear as thin rectangles on participant lifelines.
+[`UmlSequenceActivationBoxModel`](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceActivationBoxModel/) represents periods when a participant is actively processing or executing operations. Activation boxes appear as thin rectangles overlaid on participant lifelines, indicating the duration of active processing between specific messages.
#### UmlSequenceActivationBoxModel Properties
| Property | Type | Description |
|---|---|---|
-| id | string \| number | A unique identifier for the activation box |
-| startMessageID | string \| number | ID of the message that initiates the activation |
-| endMessageID | string \| number | ID of the message that terminates the activation |
+| id | string \| number | A unique identifier for the activation box. |
+| startMessageID | string \| number | ID of the message that initiates the activation.. |
+| endMessageID | string \| number | ID of the message that terminates the activation. |
-The following code example illustrates how to create activation boxes:
+#### Creating Activation Boxes
+
+The following example demonstrates how to create activation boxes that span specific message sequences:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -108,11 +123,20 @@ The following code example illustrates how to create activation boxes:
### Fragments
-[UmlSequenceFragmentModel](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceFragmentModel/) groups a set of messages based on specific conditions in a sequence diagram. They are displayed as rectangular enclosures that visually separate conditional or looping interactions.
+[`UmlSequenceFragmentModel`](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceFragmentModel/) represents logical groupings of messages based on specific conditions or control structures. Fragments appear as rectangular enclosures that visually organize conditional logic, loops, and alternative execution paths within sequence diagrams.
+
+#### Fragment Applications
+
+Fragments are essential for modeling:
+- Conditional logic (if-then-else statements).
+- Iterative processes (loops and repetitions).
+- Optional operations that may or may not execute.
+- Error handling and exception flows.
+- Parallel processing scenarios.
-#### Types of Fragments
+#### Fragment Types
-The [UmlSequenceFragmentType](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceFragmentType/) enum defines the following fragment types:
+The [`UmlSequenceFragmentType`](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceFragmentType/) enum defines the following fragment types:
| Fragment Type | Description | Example |
|---------------|-------------|--------|
@@ -124,19 +148,21 @@ The [UmlSequenceFragmentType](https://ej2.syncfusion.com/react/documentation/api
| Property | Type | Description |
|---|---|---|
-| id | string \| number | A unique identifier for the fragment |
-| type | UmlSequenceFragmentType | Type of the fragment (Optional, Loop, Alternative) |
-| conditions | UmlSequenceFragmentConditionModel[] | Collection of conditions for the fragment |
+| id | string \| number | A unique identifier for the fragment. |
+| type | UmlSequenceFragmentType | Type of the fragment (Optional, Loop, Alternative). |
+| conditions | UmlSequenceFragmentConditionModel[] | Collection of conditions for the fragment. |
#### UmlSequenceFragmentConditionModel Properties
| Property | Type | Description |
|---|---|---|
-| content | string | Text describing the condition or parameter |
-| messageIds | (string \| number)[] | Collection of message IDs included in this condition section |
-| fragmentIds | string[] | Collection of nested fragments ids (for complex structures) |
+| content | string | Text describing the condition or parameter. |
+| messageIds | (string \| number)[] | Collection of message IDs included in this condition section. |
+| fragmentIds | string[] | Collection of nested fragments ids (for complex structures). |
-The following code example illustrates how to create fragments:
+#### Creating Fragments
+
+The following example illustrates how to create fragments with different condition types:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -149,9 +175,11 @@ The following code example illustrates how to create fragments:
{% previewsample "page.domainurl/code-snippet/diagram/umlsequencediagram/umlsequencediagram-4" %}
-### Customizing Participant Spacing in Sequence Diagram
+## Customization Options
+
+### Adjusting Participant Spacing
-The [spaceBetweenParticipants](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceDiagramModel/#spaceBetweenParticipants) property in `UmlSequenceDiagramModel` controls the horizontal spacing between participants. The default value is 100, and it can be adjusted based on your layout requirements.
+The [`spaceBetweenParticipants`](https://ej2.syncfusion.com/react/documentation/api/diagram/UmlSequenceDiagramModel/#spaceBetweenParticipants) property controls the horizontal spacing between participants in the sequence diagram. Adjust this value to accommodate longer message labels or improve diagram readability.
```javascript
// Define the UML Sequence Diagram model
diff --git a/ej2-react/diagram/undo-redo.md b/ej2-react/diagram/undo-redo.md
index 0e44738f6..2f964f7e7 100644
--- a/ej2-react/diagram/undo-redo.md
+++ b/ej2-react/diagram/undo-redo.md
@@ -1,30 +1,32 @@
---
layout: post
-title: Undo redo in React Diagram component | Syncfusion®
-description: Learn here all about Undo redo in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Undo redo in React Diagram Component | Syncfusion®
+description: Learn how to implement undo and redo functionality with history management in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Undo redo
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Undo redo in React Diagram component
+# Undo and Redo in React Diagram Component
-Diagram tracks the history of actions that are performed after initializing the diagram and provides support to reverse and restore those changes.
+The React Diagram component automatically tracks all user interactions and programmatic changes, providing robust undo and redo functionality. This feature enables users to reverse or restore actions, making diagram editing more intuitive and error-tolerant.
-## Undo and redo
+## Basic Undo and Redo Operations
-Diagram provides built-in support to track the changes that are made through interaction and through public APIs. The changes can be reverted or restored either through shortcut keys or through commands.
+The diagram provides built-in support to track changes made through both user interactions and public API calls. These changes can be reversed or restored using keyboard shortcuts or programmatic commands.
-N> If you want to use Undo-Redo in diagram, you need to inject UndoRedo in the diagram.
+N> The UndoRedo module must be injected to access undo/redo features in the diagram component.
-## Undo/redo through shortcut keys
+### Keyboard Shortcuts
-Undo/redo commands can be executed through shortcut keys. Shortcut key for undo is **`Ctrl+z`** and shortcut key for redo is **`Ctrl+y`**.
+Use these standard keyboard shortcuts for quick undo/redo operations:
+- **Undo**: `Ctrl+Z`
+- **Redo**: `Ctrl+Y`
-## Undo/redo through public APIs
+### Programmatic undo and redo
-The client-side methods [`undo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#undo) and [`redo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#redo) help you to revert/restore the changes. The following code example illustrates how to undo/redo the changes through script.
+The [`undo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#undo) and [`redo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#redo) methods allow you to control undo/redo operations programmatically. The following example demonstrates how to implement these methods:
```ts
@@ -47,16 +49,21 @@ diagramInstance.undo();
// Restores the last undone action
diagramInstance.redo();
```
+### Enabling and Disabling Undo/Redo
-Undo/Redo for diagram can be enabled/disabled with the [`constraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramConstraints/) property of diagram.
+Undo/Redo for diagram can be enabled/disabled with the [`constraints`](https://helpej2.syncfusion.com/react/documentation/api/diagram/diagramConstraints/) property of the diagram component.
-When a change in the diagram is reverted or restored (undo/redo), the [`historyChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#historychange) event gets triggered.
+### History Change Events
-## Group multiple changes
+The [`historyChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#historychange) event triggers whenever an action is undone or redone, allowing you to respond to history state changes.
-History list allows to revert or restore multiple changes through a single undo/redo command. For example, revert/restore the fill color change of multiple elements at a time.
+## Advanced history management
-The diagram method [`startGroupAction`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#startgroupaction) allows you to log multiple actions at a time in the history manager stack. It is easier to undo or revert the changes made in the diagram in a single undo/redo process instead of reverting every actions one by one.The diagram method [`endGroupAction`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#endgroupaction) allows you to end the group actions that are stored in the stack history. The following code illustrates how to undo/redo multiple fillColor change of a node at a time.
+### Grouping multiple actions
+
+Group related changes into a single undo/redo operation using the history grouping feature. This approach allows users to undo or redo multiple related changes simultaneously rather than reversing each action individually.
+
+Use [`startGroupAction`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#startgroupaction)to begin grouping actions and [`endGroupAction`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#endgroupaction) to complete the group. The following example shows how to group multiple fill color changes:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -69,9 +76,8 @@ The diagram method [`startGroupAction`](https://helpej2.syncfusion.com/react/doc
{% previewsample "page.domainurl/code-snippet/diagram/undoredo/groupAction-cs1" %}
-## Stack Limit
-
-The [`stackLimit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#stacklimit) property of history manager is used to limits the number of actions to be stored on the history manager.
+### Managing History Stack Size
+The [`stackLimit`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#stacklimit) property controls the maximum number of actions stored in the history manager. Setting an appropriate limit helps manage memory usage in applications with extensive editing operations.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -84,9 +90,9 @@ The [`stackLimit`](https://helpej2.syncfusion.com/react/documentation/api/diagra
{% previewsample "page.domainurl/code-snippet/diagram/undoredo/es5Connect-cs6" %}
-## Restrict Undo/Redo
+### Restricting History Logging
-Undo, Redo process can be avoided for particular element by using [`canLog`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#canlog) property in the history manager. The following example illustrates how to prevent history entry using `canLog` function.
+Prevent specific actions from being recorded in the history using the [`canLog`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#canlog) property. This feature is useful when certain operations should not be undoable.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -99,7 +105,9 @@ Undo, Redo process can be avoided for particular element by using [`canLog`](htt
{% previewsample "page.domainurl/code-snippet/diagram/undoredo/es5Connect-cs5" %}
-## undo/redo stack
+## History Stack Inspection
+
+### Accessing Undo and Redo Stacks
The [`undoStack`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#undostack) property is used to get the collection of undo actions which should be performed in the diagram. The [`redoStack`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#redostack) property is used to get the collection of redo actions which should be performed in the diagram. The undoStack/redoStack is the read-only property.
@@ -126,9 +134,9 @@ let undoStack = diagramInstance.historyManager.undoStack;
let redoStack = diagramInstance.historyManager.redoStack;
```
-## canUndo/canRedo
+### Checking Availability of Undo and Redo Operations
-The [`canUndo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#canundo) property returns true if there are actions in the undo history stack; otherwise, it returns false. This property helps identify whether any actions are present in the undo stack.The [`canRedo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#canredo) property returns true if there are actions in the redo history stack; otherwise, it returns false. This property helps identify whether any actions are present in the redo stack.
+The [`canUndo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#canundo) and [`canRedo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#canredo) properties indicate whether undo or redo operations are available. These properties return **true** when actions exist in their respective history stacks.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -141,9 +149,9 @@ The [`canUndo`](https://helpej2.syncfusion.com/react/documentation/api/diagram/h
{% previewsample "page.domainurl/code-snippet/diagram/undoredo/es5CurrentEntry-cs1" %}
-## Current entry
+### Current Entry Tracking
-While performing interactions with a node or connector, the current history entry is added to the [`currentEntry`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#currententry) property of the [`historyManager`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#historymanager).
+During user interactions with nodes or connectors, the current history entry is stored in the [`currentEntry`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#currententry) property of the [`historyManager`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#historymanager).
The following code shows how to get the current entry from the diagram history:
@@ -158,18 +166,20 @@ The following code shows how to get the current entry from the diagram history:
{% previewsample "page.domainurl/code-snippet/diagram/undoredo/es5CurrentEntry-cs1" %}
-## Clear history
+## History Management Utilities
+
+### Clearing History
-The [`clearHistory`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#clearhistory) method of diagram is used to remove all the recorded actions from the undo and redo history.
+The [`clearHistory`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#clearhistory) method to remove all recorded actions from both undo and redo history stacks:
```ts
//Clears all the histories
diagramInstance.clearHistory();
```
-## Get history stack
+### Retrieving History Stacks
-The [`getHistoryStack`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#gethistorystack) method of the diagram retrieves the [`undoStack`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#undostack) or [`redoStack`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#redostack) from the historyManager. This method takes a single parameter, isUndoStack. Pass true to get the undoStack or false to get the redoStack.
+The [`getHistoryStack`](https://helpej2.syncfusion.com/react/documentation/api/diagram/#gethistorystack) method retrieves either the [`undoStack`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#undostack) or [`redoStack`](https://helpej2.syncfusion.com/react/documentation/api/diagram/history/#redostack) from the history manager. Pass **true** to get the undo stack or false to get the redo stack:
```ts
// Fetch undoStack from history manager
@@ -180,9 +190,11 @@ diagramInstance.getHistoryStack(false)
```
-## History change event
+## Event Handling
+
+### History Change Event
-The [`historyChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iHistoryChangeArgs/) event triggers, whenever the interaction of the node and connector is take place. When interacting, the entries get added to the history manager to trigger this event. The following example shows how to get this event in diagram.
+The [`historyChange`](https://helpej2.syncfusion.com/react/documentation/api/diagram/iHistoryChangeArgs/) event triggers whenever interactions with nodes and connectors occur. This event provides an opportunity to implement custom logic or UI updates based on history state changes:
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
diff --git a/ej2-react/diagram/user-handle.md b/ej2-react/diagram/user-handle.md
index 2df1a8b91..1477b8bde 100644
--- a/ej2-react/diagram/user-handle.md
+++ b/ej2-react/diagram/user-handle.md
@@ -1,20 +1,24 @@
---
layout: post
-title: User handle in React Diagram component | Syncfusion®
-description: Learn here all about User handle in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: User handle in React Diagram Component | Syncfusion®
+description: Learn here all about User handle in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: User handle
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# User handle in React Diagram component
+# User Handle in React Diagram Component
-User handles are used to add frequently used commands around the selector.
+User handles are interactive UI elements that provide quick access to frequently used commands around selected diagram elements. They appear as customizable icons positioned around nodes and connectors, enabling users to perform actions like cloning, deleting, or editing without accessing traditional menus or toolbars.
+
+The React Diagram component supports two types of user handles:
+- **User handles**: Appear when elements are selected and are defined globally for all selected items.
+- **Fixed user handles**: Permanently visible on specific nodes or connectors, regardless of selection state.
## Create user handle
-To create user handles, define and add them to the [`userHandles`](https://helpej2.syncfusion.com/react/documentation/api/diagram/selectorModel/#userhandles) collection of the [`selectedItems`](https://ej2.syncfusion.com/react/documentation/api/diagram#selecteditems) property. The [`name`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#name) property of userHandles is used to define the name of the user handle, which can then be used at runtime for identification and customization. The [`pathData`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#pathdata) property is used to define the path data of userhandle.
+To create user handles, define and add them to the [`userHandles`](https://helpej2.syncfusion.com/react/documentation/api/diagram/selectorModel/#userhandles) collection of the [`selectedItems`](https://ej2.syncfusion.com/react/documentation/api/diagram#selecteditems) property. The [`name`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#name) property of userHandles is used to define the name of the user handle, which can then be used at runtime for identification and customization. The [`pathData`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#pathdata) property is used to define the SVG path data that determines the visual appearance of the user handle icon.
The following example shows how to render user handle.
@@ -29,9 +33,9 @@ The following example shows how to render user handle.
{% previewsample "page.domainurl/code-snippet/diagram/interaction/es5UserHandle-cs3" %}
-## Customize User handle click
+## Customize User Handle Click
-When the user handle is clicked, the [`onUserHandleMouseDown`](https://ej2.syncfusion.com/react/documentation/api/diagram/#onuserhandlemousedown) event allows us to identify which user handle was clicked using the name property of userHandle. Based on this name, we can customize the diagram elements accordingly. Several events are triggered while interacting with a user handle. In the following example, we use the [`onUserHandleMouseDown`](https://ej2.syncfusion.com/react/documentation/api/diagram/#onuserhandlemousedown) event to clone nodes on user handle click.
+When the user handle is clicked, the [`onUserHandleMouseDown`](https://ej2.syncfusion.com/react/documentation/api/diagram/#onuserhandlemousedown) event allows us to identify which user handle was clicked using the name property of userHandle. Based on this name, we can customize the diagram elements accordingly. Several events are triggered while interacting with a user handle. In the following example, we use the [`onUserHandleMouseDown`](https://ej2.syncfusion.com/react/documentation/api/diagram/#onuserhandlemousedown) event is used to clone nodes on user handle click.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -46,23 +50,23 @@ When the user handle is clicked, the [`onUserHandleMouseDown`](https://ej2.syncf
## Alignment
-User handles can be aligned relative to the node boundaries. It has [`margin`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#margin), [`offset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#offset), [`side`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#side), [`horizontalAlignment`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#horizontalalignment), and [`verticalAlignment`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#verticalalignment) properties to align user handle based on user's needs.
+User handles can be precisely positioned relative to node boundaries using alignment properties. The positioning system provides [`margin`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#margin), [`offset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#offset), [`side`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#side), [`horizontalAlignment`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#horizontalalignment), and [`verticalAlignment`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#verticalalignment) properties to align user handles based on specific requirements.
### Offset
-The [`offset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#offset), property of [`userHandles`](https://helpej2.syncfusion.com/react/documentation/api/diagram/selectorModel/#userhandles) aligns the user handle based on fractions. For example, 0 represents the top-left corner, 1 represents the top-right corner, and 0.5 represents the top-center.
+The [`offset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#offset), property of `userHandles` aligns the user handle based on fractions. For example, 0 represents the top-left corner, 1 represents the top-right corner, and 0.5 represents the top-center.
### Side
-The [`side`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#side) property of [`userHandles`](https://helpej2.syncfusion.com/react/documentation/api/diagram/selectorModel/#userhandles) aligns the user handle using the following options: [`Top`](https://ej2.syncfusion.com/react/documentation/api/diagram/side#top), [`Bottom`](https://ej2.syncfusion.com/react/documentation/api/diagram/side#bottom), [`Left`](https://ej2.syncfusion.com/react/documentation/api/diagram/side#left), and [`Right`](https://ej2.syncfusion.com/react/documentation/api/diagram/side#right).
+The [`side`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#side) property of `userHandles` aligns the user handle using the following options: [`Top`](https://ej2.syncfusion.com/react/documentation/api/diagram/side#top), [`Bottom`](https://ej2.syncfusion.com/react/documentation/api/diagram/side#bottom), [`Left`](https://ej2.syncfusion.com/react/documentation/api/diagram/side#left), and [`Right`](https://ej2.syncfusion.com/react/documentation/api/diagram/side#right).
-### Horizontal and vertical alignments
+### Horizontal and Vertical Alignments
-The [`horizontalAlignment`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#horizontalalignment) property of [`userHandles`](https://helpej2.syncfusion.com/react/documentation/api/diagram/selectorModel/#userhandles) is used to set how the user handle is horizontally aligned at the position based on the [`offset`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#offset). The [`verticalAlignment`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#verticalalignment) property is used to set how user handle is vertically aligned at the position.
+The `horizontalAlignment` property of `userHandles` is used to set how the user handle is horizontally aligned at the position based on the `offset`. The `verticalAlignment` property determines how user handle is vertically aligned at the position..
-### Margin for the user handle
+### Margin for the User Handle
-The [`margin`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#margin) property adds blank space to any of the four sides of the user handle, allowing for precise displacement.
+The [`margin`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#margin) property adds blank space to any of the four sides of the user handle, providing precise displacement from the calculated position.
In the following example, the user handle is aligned to the bottom-right corner of the node.
@@ -90,7 +94,7 @@ The following table shows all the possible alignments of user handle around the
| 1 | Top ||
| 1 | Bottom ||
-## User handle tooltip
+## User Handle Tooltip
The diagram provides support to show a tooltip when the mouse hovers over any user handle. To show the tooltip on mouse hover, set the [`tooltip`](https://helpej2.syncfusion.com/react/documentation/api/diagram/userHandleModel/#tooltip) property of the user handle with the tooltip [`content`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramTooltipModel/#content) as shown in the following example.
@@ -105,7 +109,7 @@ The diagram provides support to show a tooltip when the mouse hovers over any us
{% previewsample "page.domainurl/code-snippet/diagram/interaction/es5UserHandle-cs6" %}
-You can also customize other properties of the tooltip, such as [`position`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramTooltipModel/#position), [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramTooltipModel/#width), [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramTooltipModel/#height), etc. For more information refer to the [`tooltip`](./tooltip) section.
+Additional tooltip properties can be customized, such as [`position`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramTooltipModel/#position), [`width`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramTooltipModel/#width), [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramTooltipModel/#height), etc. For more information refer to the [`tooltip`](./tooltip) section.
## Appearance
@@ -124,13 +128,13 @@ The following example demonstrates, how to use these properties to customize the
{% previewsample "page.domainurl/code-snippet/diagram/interaction/es5UserHandle-cs2" %}
-## Multiple user handle
+## Multiple User Handle
-Multiple user handles can be rendered for the selected objects (nodes/connectors) at a time to perform different operations.
+Multiple user handles can be rendered for the selected objects (nodes/connectors) simultaneously to perform different operations on the same element.
-### Disable Nodes and disable Connectors
+### Disable Nodes and Disable Connectors
-User handles are typically defined within the [`selectedItems`](https://ej2.syncfusion.com/react/documentation/api/diagram#selecteditems) property of the diagram, applying them universally to both nodes and connectors. However, in some scenarios, specific user handles may need to be excluded from connectors or nodes selectively. To address this, the disableNodes and disableConnectors properties come into play. These properties allow certain user handles to be disabled based on the type of selected item.
+User handles are typically defined within the [`selectedItems`](https://ej2.syncfusion.com/react/documentation/api/diagram#selecteditems) property of the diagram, applying them universally to both nodes and connectors. However, in some scenarios, specific user handles may need to be excluded from connectors or nodes selectively. To address this requirement, the disableNodes and disableConnectors properties are available. These properties allow certain user handles to be disabled based on the type of selected item.
In the example below, multiple user handles are utilized for various functionalities, with some handles hidden selectively for nodes or connectors depending on their intended functionality.
@@ -145,9 +149,9 @@ In the example below, multiple user handles are utilized for various functionali
{% previewsample "page.domainurl/code-snippet/diagram/interaction/es5MultipleUserHandle-cs1" %}
-## Different types of user handle
+## Different Types of User Handle
-Diagram provides support to render different types of user handles:
+The diagram provides support to render different types of user handles based on the content source:
* `Source`: Renders an image as a user handle using an image source.
* `Content`: Renders a user handle using SVG content.
@@ -161,9 +165,9 @@ The precedence order for user handles is as follows:
3. Source
4. userHandleTemplate
-This means that if multiple options are used for the user handle, the one with higher precedence will be rendered.
+This means that if multiple options are specified for the same user handle, the one with higher precedence will be rendered.
-The below example code demonstrating different types of user handles.
+The below example code demonstrates different types of user handles.
{% tabs %}
{% highlight js tabtitle="index.jsx" %}
@@ -176,9 +180,9 @@ The below example code demonstrating different types of user handles.
{% previewsample "page.domainurl/code-snippet/diagram/interaction/es5UserHandleTypes-cs1" %}
-## User handle events
+## User Handle Events
-When interacting with user handles, certain events are triggered that can be used to customize the appearance and functionality of the handles. The user handle events are explained below.
+When interacting with user handles, specific events are triggered that can be used to customize the appearance and functionality of the handles. The user handle events are explained below.
* [`click`](https://ej2.syncfusion.com/react/documentation/api/diagram/#click) - Triggered when the user handle is clicked.
@@ -200,13 +204,13 @@ In the following example, the above events are used to customize the appearance
{% previewsample "page.domainurl/code-snippet/diagram/interaction/es5UserHandleEvents-cs1" %}
-## Fixed user handles
+## Fixed User Handles
-Fixed user handles are used to perform specific actions when interacted with. Unlike regular user handles, [`fixedUserHandles`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/) are defined within the node/connector object, allowing different fixed user handles to be added to different nodes.
+Fixed user handles are used to perform specific actions when interacted with. Unlike regular user handles, [`fixedUserHandles`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/) are defined within individual node or connector objects. This allows different fixed user handles to be added to different elements, and these handles remain visible and positioned consistently, regardless of selection state.
-### Create fixed user handles
+### Create Fixed User Handles
-To create the [`fixedUserHandles`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/), define and add them to the collection of [`nodes`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeModel/) and [`connectors`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectorModel/). The [`pathData`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#pathdata) property of [`fixedUserHandles`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/) is used to define the path data for the fixed user handle. The [`id`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#id) property in `fixedUserHandles` assigns a unique identifier to each handle. This identifier helps locate and modify fixed user handles during runtime. You can handle the click event of a fixed user handle using the [`fixedUserHandleClick`](https://ej2.syncfusion.com/react/documentation/api/diagram/#fixeduserhandleclick) event. This event allows customization based on the type of fixed user handle clicked.
+To create the [`fixedUserHandles`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/), define and add them to the collection of [`nodes`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeModel/) and [`connectors`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectorModel/). The [`pathData`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#pathdata) property of `fixedUserHandles` is used to define the path data for the fixed user handle. The [`id`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#id) property in `fixedUserHandles` assigns a unique identifier to each handle. This identifier helps locate and modify fixed user handles during runtime. You can handle the click event of a fixed user handle using the [`fixedUserHandleClick`](https://ej2.syncfusion.com/react/documentation/api/diagram/#fixeduserhandleclick) event. This event allows customization based on the type of fixed user handle clicked.
The following code example demonstrates how to create fixed user handles for nodes and connectors and how to handle fixed user handle click:
@@ -225,16 +229,16 @@ The following code example demonstrates how to create fixed user handles for nod
### Alignment
-Fixed user handles can be aligned relative to the node boundaries. It has [`margin`](https://ej2.syncfusion.com/react/documentation/api/accumulation-chart/marginModel/), [`offset`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#offset), [`padding`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#padding) properties to align them based on user's needs.
+Fixed user handles can be aligned relative to the node boundaries. It has [`margin`](https://ej2.syncfusion.com/react/documentation/api/accumulation-chart/marginModel/), `offset`, [`padding`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#padding) properties to align them based on user's needs.
#### Margin
-Margin is an absolute value used to add some blank space in any one of its four sides. The fixed user handle can be displaced with the [`margin`](https://ej2.syncfusion.com/react/documentation/api/accumulation-chart/marginModel/) property.
+Margin is an absolute value used to add some blank space in any one of its four sides. The fixed user handle can be displaced with the `margin` property.
#### Offset
-The [`offset`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#offset) property of fixed user handle is used to align the user handle based on the `x` and `y` points. (0,0) represents the top-left corner and (1,1) represents the bottom-right corner.
+The `offset` property of fixed user handle is used to align the user handle based on the `x` and `y` points. (0,0) represents the top-left corner and (1,1) represents the bottom-right corner.
#### Padding
@@ -268,13 +272,13 @@ The following table shows all the possible alignments of fixed user handle aroun
>Note: Both `displacement` and `alignment` are applicable only to connector fixed user handles.
-#### Customizing the connector fixed user handle
+#### Customizing the Connector Fixed User Handle
The connector fixed user handle can be aligned relative to the connector boundaries. It has alignment, displacement and offset settings. The [`displacement`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectorFixedUserHandleModel/#displacement) property displaces the handle from its aligned position and its functioning only when the [`alignment`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectorFixedUserHandleModel/#alignment) property is set to 'After' or 'Before'.
##### Offset
-The [`offset`](https://ej2.syncfusion.com/react/documentation/api/diagram/connectorFixedUserHandleModel/#offset), property of fixed user handle aligns the fixed user handle based on fractions. For example, 0 represents the left or top corner, 1 represents the bottom or right corner, and 0.5 represents the center.
+The `offset`, property of fixed user handle aligns the fixed user handle based on fractions. For example, 0 represents the left or top corner, 1 represents the bottom or right corner, and 0.5 represents the center.
##### Alignment
@@ -322,7 +326,7 @@ The following code explains how to customize the alignment of connector fixed us
{% previewsample "page.domainurl/code-snippet/diagram/interaction/es5ConnectorFixedUserHandle-cs1" %}
-### Fixed user handle tooltip
+### Fixed User Handle Tooltip
The diagram provides support to show a tooltip when the mouse hovers over any fixed user handle. To show the tooltip on mouse hover, set the [`tooltip`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#tooltip) property of the fixed user handle with the tooltip [`content`](https://ej2.syncfusion.com/react/documentation/api/diagram/diagramTooltipModel/#content) as shown in the following example.
@@ -349,13 +353,13 @@ The [`height`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFi
#### Style
-The fixed user handle's [`iconStrokeColor`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#iconstrokecolor) and [`iconStrokeWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#iconstrokewidth) property used to change the stroke color and stroke width of the given `pathData`.
+The fixed user handle's [`iconStrokeColor`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#iconstrokecolor) and `iconStrokeWidth` property used to change the stroke color and stroke width of the given `pathData`.
-The fixed user handle's [`handleStrokeColor`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#handlestrokecolor) and [`handleStrokeWidth`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#handlestrokewidth), properties are used to define the stroke color and stroke width of the fixed user handle and the [`fill`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#fill), property is used to define the fill color of fixed user handle.
+The fixed user handle's `handleStrokeColor`and `handleStrokeWidth`, properties are used to define the stroke color and stroke width of the fixed user handle and the [`fill`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#fill), property is used to define the fill color of fixed user handle.
-The [`cornerRadius`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#cornerradius) property of the fixed user handle is used to apply border radius for the fixed user handle.
+The `cornerRadius` property of the fixed user handle is used to apply border radius for the fixed user handle.
-The [`visibility`](https://ej2.syncfusion.com/react/documentation/api/diagram/nodeFixedUserHandleModel/#visibility) property of the fixed user handle enables or disables the visibility of fixed user handle.
+The `visibility` property of the fixed user handle enables or disables the visibility of fixed user handle.
The following example demonstrates, how to use these properties to customize the appearance of the fixed user handle.
@@ -385,7 +389,7 @@ Fixed user handles are interactive elements added to nodes and connectors. Their
{% previewsample "page.domainurl/code-snippet/diagram/interaction/es5FixedUserHandleTemplate-cs1" %}
-### Fixed user handle events
+### Fixed User Handle Events
When interacting with fixed user handles, certain events are triggered that can be used to customize the appearance and functionality of the handles. The fixed user handle events are explained below.
diff --git a/ej2-react/diagram/virtualization.md b/ej2-react/diagram/virtualization.md
index b396c9ecb..115f8ce7c 100644
--- a/ej2-react/diagram/virtualization.md
+++ b/ej2-react/diagram/virtualization.md
@@ -1,22 +1,40 @@
---
layout: post
-title: Virtualization in React Diagram component | Syncfusion®
-description: Learn here all about Virtualization in Syncfusion® React Diagram component of Syncfusion Essential® JS 2 and more.
+title: Virtualization in React Diagram Component | Syncfusion®
+description: Learn here all about Virtualization in Syncfusion® React Diagram Component of Syncfusion Essential® JS 2 and more.
control: Virtualization
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
-# Virtualization in React Diagram component
+# Virtualization in React Diagram Component
-Virtualization is a technique to optimize the performance of diagrams, especially when working with larger diagrams
+Virtualization is a performance optimization technique that significantly improves diagram rendering and interaction speed, particularly when working with large-scale diagrams containing hundreds or thousands of nodes and connectors.
-## Virtualization in Diagram
+## Understanding Virtualization in Diagram
-Virtualization optimizes the diagram performance by loading only the diagramming objects within the visible area, or ViewPort, of the Scroll Viewer. This means that only the nodes and connectors that are currently in view are loaded, while the remaining objects are loaded dynamically as they come into view.
+Virtualization enhances diagram performance by implementing on-demand loading of diagramming objects. Only the nodes and connectors currently visible within the diagram's viewport are rendered and processed, while objects outside the visible area remain unloaded until they enter the view during scrolling or panning operations.
-This feature significantly enhances performance, especially when working with diagrams containing a large number of nodes and connectors. By reducing the number of objects that need to be processed at any given time, virtualization ensures smoother interactions, such as loading and dragging items within the diagram.
+This selective rendering approach provides substantial performance benefits:
+
+* **Reduced Memory Usage**: Only visible objects consume memory resources.
+* **Faster Initial Load**: Diagrams render quickly regardless of total object count.
+* **Smooth Interactions**: Dragging, zooming, and panning remain responsive.
+* **Scalable Performance**: Performance remains consistent as diagram size increases.
+
+## When to Enable Virtualization
+
+Virtualization is recommended for diagrams that meet any of these criteria:
+
+* Contain 100 or more nodes and connectors.
+* Experience performance issues during scrolling or zooming.
+* Require frequent updates to large datasets.
+* Display complex organizational charts, network diagrams, or flowcharts.
+
+## Enabling Virtualization
+
+To activate virtualization, include the `Virtualization` constraint in the diagram's constraints property. The virtualization feature works in conjunction with the diagram's scrolling capabilities to manage object loading dynamically.
To enable virtualization in a diagram, you need to include the virtualization constraint in the diagram's constraints. For more information, refer to the [`diagram constraints`](https://ej2.syncfusion.com/react/documentation/api/diagram/#constraints).
diff --git a/ej2-react/introduction.md b/ej2-react/introduction.md
index c620049bd..07821d523 100644
--- a/ej2-react/introduction.md
+++ b/ej2-react/introduction.md
@@ -12,7 +12,11 @@ domainurl: ##DomainURL##
Syncfusion® React (Essential® JS 2) is a modern UI components library built from the ground up to be lightweight, responsive, modular, and touch friendly.
+<<<<<<< HEAD
> **Ready to streamline your Syncfusion® React development?** Discover the full potential of Syncfusion® React components with Syncfusion® AI Coding Assistants. Effortlessly integrate, configure, and enhance your projects with intelligent, context-aware code suggestions, streamlined setups, and real-time insights—all seamlessly integrated into your preferred AI-powered IDEs like VS Code, Cursor, Syncfusion® CodeStudio and more. [Explore Syncfusion® AI Coding Assistants](https://ej2.syncfusion.com/react/documentation/ai-coding-assistants/overview)
+=======
+> **Ready to streamline your Syncfusion® React development?** Discover the full potential of Syncfusion® React components with Syncfusion® AI Coding Assistant. Effortlessly integrate, configure, and enhance your projects with intelligent, context-aware code suggestions, streamlined setups, and real-time insights—all seamlessly integrated into your preferred AI-powered IDEs like VS Code, Cursor, Syncfusion® CodeStudio and more. [Explore Syncfusion® AI Coding Assistant](https://ej2.syncfusion.com/react/documentation/ai-coding-assistants/overview)
+>>>>>>> remotes/origin/development
## Components list
diff --git a/ej2-react/licensing/license-key-generation.md b/ej2-react/licensing/license-key-generation.md
index 7530b12e3..cb3b7b2de 100644
--- a/ej2-react/licensing/license-key-generation.md
+++ b/ej2-react/licensing/license-key-generation.md
@@ -8,9 +8,13 @@ documentation: ug
domainurl: ##DomainURL##
---
-# Generate Syncfusion® ReactJS License key
+# Generate Syncfusion® ReactJS License key
+<<<<<<< HEAD
Syncfusion® license keys can be generated from the [License & Downloads](https://syncfusion.com/account/downloads) or [Trial & Downloads](https://www.syncfusion.com/account/manage-trials/downloads) section of the Syncfusion® website.
+=======
+Syncfusion® license keys can be generated from the [License & Downloads](https://syncfusion.com/account/downloads) or [Trial & Downloads](https://www.syncfusion.com/account/manage-trials/downloads) section of the Syncfusion® website.
+>>>>>>> remotes/origin/development

diff --git a/ej2-react/treegrid/frozen.md b/ej2-react/treegrid/frozen.md
index be654aff9..5ab34687b 100644
--- a/ej2-react/treegrid/frozen.md
+++ b/ej2-react/treegrid/frozen.md
@@ -2,13 +2,21 @@
layout: post
title: Frozen in React TreeGrid | Syncfusion
description: Learn here all about Frozen in Syncfusion React TreeGrid component of Syncfusion Essential JS 2 and more.
+<<<<<<< HEAD
control: Frozen
+=======
+control: Frozen
+>>>>>>> remotes/origin/development
platform: ej2-react
documentation: ug
domainurl: ##DomainURL##
---
+<<<<<<< HEAD
# Frozen in React TreeGrid
+=======
+# Frozen in React TreeGrid
+>>>>>>> remotes/origin/development
## Frozen rows and columns
@@ -16,7 +24,12 @@ Frozen rows and columns provide an option to keep rows and columns always visibl
To use frozen rows and columns, inject the **Freeze** module in the TreeGrid.
+<<<<<<< HEAD
In this demo, [frozenColumns](https://ej2.syncfusion.com/react/documentation/api/treegrid/#frozencolumns) is set to **2** and [frozenRows](https://ej2.syncfusion.com/react/documentation/api/treegrid/#frozenrows) is set to **3**. As a result, the left two columns and top three rows remain frozen.
+=======
+In this demo, the [frozenColumns](https://ej2.syncfusion.com/react/documentation/api/treegrid/#frozencolumns) is set as **'2'** and the [frozenRows](https://ej2.syncfusion.com/react/documentation/api/treegrid/#frozenrows)
+is set as **'3'**. Hence, the left two columns and top three rows are frozen.
+>>>>>>> remotes/origin/development
{% tabs %}
{% highlight js tabtitle="app.jsx" %}
@@ -30,8 +43,14 @@ In this demo, [frozenColumns](https://ej2.syncfusion.com/react/documentation/api
### Freeze particular columns
+<<<<<<< HEAD
Use the [isFrozen](https://ej2.syncfusion.com/react/documentation/api/treegrid/column/#isfrozen) property to freeze selected columns in the TreeGrid.
In this demo, the columns with field names `taskName` and `startDate` are frozen using the `isFrozen` property.
+=======
+You can use [isFrozen](https://ej2.syncfusion.com/react/documentation/api/treegrid/column/#isfrozen) property to freeze selected columns in tree grid.
+
+In this demo, the columns with field name `taskName` and `startDate` is frozen using the `isFrozen` property.
+>>>>>>> remotes/origin/development
{% tabs %}
{% highlight js tabtitle="app.jsx" %}
@@ -45,11 +64,17 @@ In this demo, the columns with field names `taskName` and `startDate` are frozen
### Freeze direction
+<<<<<<< HEAD
Freeze TreeGrid columns on the left or right side using the [column.freeze](https://ej2.syncfusion.com/react/documentation/api/treegrid/column/#freeze) property; remaining columns are movable. The TreeGrid automatically places columns on the left or right based on the [column.freeze](https://ej2.syncfusion.[REDACTED]/#freeze) value.
Types of [column.freeze](https://ej2.syncfusion.com/react/documentation/api/treegrid/column/#freeze) directions:
* **Left**: Freezes columns on the left.
* **Right**: Freezes columns on the right.
+=======
+You can freeze the tree grid columns on the left or right side by using the [column.freeze](https://ej2.syncfusion.com/react/documentation/api/treegrid/column/#freeze) freeze property and the remaining columns will be movable. The tree grid will automatically move the columns to the left or right position based on the [column.freeze](https://ej2.syncfusion.com/react/documentation/api/treegrid/column/#freeze) value.
+
+Types of the [column.freeze](https://ej2.syncfusion.com/react/documentation/api/treegrid/column/#freeze) directions:
+>>>>>>> remotes/origin/development
In this demo, the **Task Name** column is frozen on the left and the **Priority** column is frozen on the right side of the content table.
@@ -65,7 +90,11 @@ In this demo, the **Task Name** column is frozen on the left and the **Priority*
> Freeze direction is not compatible with the [isFrozen](https://ej2.syncfusion.com/react/documentation/api/treegrid/column/#isfrozen) and [frozenColumns](https://ej2.syncfusion.com/react/documentation/api/treegrid/#frozencolumns) properties.
+<<<<<<< HEAD
### Limitations of frozen TreeGrid
+=======
+> * Freeze Direction is not compatible with the [isFrozen](https://ej2.syncfusion.com/react/documentation/api/treegrid/column/#isfrozen) and [frozenColumns](https://ej2.syncfusion.com/react/documentation/api/treegrid/#frozencolumns) properties.
+>>>>>>> remotes/origin/development
The following features are not supported with frozen rows and columns:
@@ -78,4 +107,8 @@ Additional limitations for the Freeze direction feature:
* Infinite scroll cache mode
* Freeze direction in the stacked header is not compatible with column reordering.
-> Refer to the [React TreeGrid](https://www.syncfusion.com/react-ui-components/react-tree-grid) feature tour page for feature highlights. Explore the [React TreeGrid example](https://ej2.syncfusion.com/react/demos/#/material/treegrid/treegrid-overview) to learn how to present and manipulate data.
\ No newline at end of file
+<<<<<<< HEAD
+> Refer to the [React TreeGrid](https://www.syncfusion.com/react-ui-components/react-tree-grid) feature tour page for feature highlights. Explore the [React TreeGrid example](https://ej2.syncfusion.com/react/demos/#/material/treegrid/treegrid-overview) to learn how to present and manipulate data.
+=======
+> You can refer to our [React TreeGrid](https://www.syncfusion.com/react-ui-components/react-tree-grid) feature tour page for its groundbreaking feature representations. You can also explore our [React TreeGrid example](https://ej2.syncfusion.com/react/demos/#/material/treegrid/treegrid-overview) to knows how to present and manipulate data.
+>>>>>>> remotes/origin/development