---
description: >-
  A control feature that provides additional customization options—including
  dynamic lighting, interactive mode, and event notifications for gauge value
  changes and animations.
---

# Additional Features & Events

## Overview

The Additional Features & Events group encompasses properties that extend the gauge’s capabilities beyond visual styling. These include toggling dynamic lighting (via `EnableDynamicLighting`), interactive modes (via `InteractiveMode`), and glow effects (via `EnableGlowEffect`), as well as events like `ValueChanged`, `ValueHasChanged`, `AnimationCompleted`, and `PropertyChanged` that notify the host application of state changes. This combination of extra features and event notifications allows for greater control, data binding, and interactivity within your WinForms applications.

***

### Key Points

| Aspect              | Description                                                                                                        | Code Reference / Example                                                                                                                                                              |
| ------------------- | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Dynamic Lighting    | Enables dynamic lighting effects on the gauge, enhancing its visual realism.                                       | `csharp\nmyGauge.EnableDynamicLighting = true;\nmyGauge.AmbientLightIntensity = 0.5f;`                                                                                                |
| Interactive Mode    | Allows users to modify the gauge value through mouse interactions.                                                 | `csharp\nmyGauge.InteractiveMode = true;`                                                                                                                                             |
| Glow Effect         | Provides an additional glow effect (often synonymous with neon effects) to emphasize the gauge's appearance.       | `csharp\nmyGauge.EnableGlowEffect = true;`                                                                                                                                            |
| Event Notifications | Notifies the application when the gauge value changes, when an animation completes, or when a property is updated. | `csharp\n// Example of event subscription\nmyGauge.ValueChanged += (s, e) => { /* Handle value update */ };\nmyGauge.AnimationCompleted += (s, e) => { /* Handle animation end */ };` |

***

### Best Practices

| Recommendation                   | Details                                                                                                                           | Example / Explanation                                                                                                    |
| -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| Use Events for Data Binding      | Leverage events like `ValueChanged` and `PropertyChanged` to update other UI components dynamically in response to gauge changes. | `csharp\nmyGauge.ValueChanged += (s, e) => { UpdateDisplay(); };`                                                        |
| Enable Interactivity Judiciously | Activate `InteractiveMode` only when direct user input is expected to avoid unintended value changes during passive displays.     | `csharp\n// Enable interactivity only in configuration screens\nmyGauge.InteractiveMode = isConfigurationMode;`          |
| Coordinate Additional Effects    | When using multiple visual enhancements (e.g., dynamic lighting and glow), adjust their intensities to maintain visual harmony.   | `csharp\nmyGauge.EnableDynamicLighting = true;\nmyGauge.AmbientLightIntensity = 0.5f;\nmyGauge.EnableGlowEffect = true;` |

***

### Common Pitfalls

| Issue                     | Details                                                                                                                           | Resolution / Code Example                                                                                                                |
| ------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| Overloading with Effects  | Enabling too many additional effects simultaneously (dynamic lighting, glow, interactivity) may lead to performance degradation.  | Gradually enable and test effects; for example, first enable dynamic lighting, then add glow if performance permits.                     |
| Mismanaged Event Handlers | Failing to unsubscribe from events like `ValueChanged` or `PropertyChanged` when disposing of the gauge can lead to memory leaks. | Always unsubscribe from events when the control is disposed or no longer needed:`csharp\nmyGauge.ValueChanged -= MyValueChangedHandler;` |
| Unintended Interactivity  | Enabling interactive mode in scenarios where users should only view data may lead to accidental modifications.                    | Limit interactivity to contexts where user input is expected, or disable interactive mode after use.                                     |

***

### Usage Scenarios

| Scenario                   | Description                                                                                                                         | Sample Code                                                                                                                                                          |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Data Binding in Dashboards | Use event notifications to synchronize the gauge with other dashboard components, ensuring consistent data representation.          | `csharp\nmyGauge.ValueChanged += (s, e) => { dashboardLabel.Text = myGauge.Value.ToString("F1"); };`                                                                 |
| Configuration Panels       | Enable interactive mode so that users can adjust parameters directly on the gauge during setup or calibration.                      | `csharp\n// In a configuration panel\nmyGauge.InteractiveMode = true;`                                                                                               |
| Real-Time Monitoring       | Combine dynamic lighting and glow effects to enhance visual cues, while events trigger alerts when critical thresholds are reached. | `csharp\nmyGauge.EnableDynamicLighting = true;\nmyGauge.EnableGlowEffect = true;\nmyGauge.ValueHasChanged += (s, e) => { if(e.NewValue > threshold) AlertUser(); };` |

***

### Real Life Usage Scenarios

| Scenario                  | Description                                                                                                                                                          | Sample Integration Code                                                                                                                                                                                                 |
| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Financial Data Dashboard  | In a financial dashboard, use event notifications to update related charts and widgets when the gauge value changes, and enable interactivity in configuration mode. | `csharp\n// Financial dashboard integration\nmyGauge.InteractiveMode = isConfigMode;\nmyGauge.ValueChanged += (s, e) => { UpdateOtherWidgets(myGauge.Value); };`                                                        |
| Industrial Control System | In an industrial setting, enable interactive adjustments for calibration, and use dynamic lighting to make the gauge more readable under varying conditions.         | `csharp\n// Industrial control integration\nmyGauge.InteractiveMode = true;\nmyGauge.EnableDynamicLighting = true;\nmyGauge.ValueHasChanged += (s, e) => { LogCalibrationChange(e.PreviousValue, e.NewValue); };`       |
| Educational Tools         | For interactive learning applications, allow users to manipulate the gauge and provide real-time event feedback to illustrate cause-and-effect relationships.        | `csharp\n// Educational gauge configuration\nmyGauge.InteractiveMode = true;\nmyGauge.ShowTooltip = true;\nmyGauge.TooltipFormat = "{0:F2}";\nmyGauge.AnimationCompleted += (s, e) => { DisplayCompletionMessage(); };` |

***

### Troubleshooting Tips

| Tip                         | Explanation                                                                                                                                   | Action                                                                                                                                                               |
| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Unresponsive Event Handling | If events seem not to fire, ensure that interactive and dynamic features are enabled and that event subscriptions are set up correctly.       | Double-check that properties like `InteractiveMode` are true and that event handlers are attached properly: `csharp\nmyGauge.ValueChanged += HandlerMethod;`         |
| Performance Issues          | Extensive interactivity and dynamic effects might slow down the control; profile your application if lag is observed.                         | Consider reducing the intensity of dynamic effects or temporarily disabling non-critical features (e.g., `EnableGlowEffect`) during performance-critical operations. |
| Inconsistent Data Updates   | If the gauge does not update other UI components reliably, verify that event handlers (such as for `ValueChanged`) are correctly implemented. | Use debugging or logging within event handlers to ensure they trigger as expected and pass the correct values.                                                       |

***

### Review

| Aspect                        | Comments                                                                                                                                                       | Suggestions                                                                                                                   |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| Enhanced Interactivity        | The additional features significantly boost the gauge’s functionality by allowing user input and enabling dynamic visual responses.                            | Use events to integrate seamlessly with other UI elements; document any custom event handling thoroughly.                     |
| Event Notification Clarity    | Events such as `ValueChanged` and `AnimationCompleted` help keep the application in sync with the gauge’s state.                                               | Consider grouping related events in helper classes or using custom event args to provide more detailed information if needed. |
| Integration and Customization | The additional features are straightforward to integrate but require careful management to avoid performance pitfalls, especially in data-intensive scenarios. | Follow best practices for event subscriptions and ensure that interactive features are enabled only when required.            |

***

### Summary

| Summary Point                      | Description                                                                                                                                                             |
| ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Feature Overview                   | Provides additional customization through properties like dynamic lighting, interactive mode, and glow effects, along with event notifications for gauge state changes. |
| Core Properties                    | Key properties include `EnableDynamicLighting`, `InteractiveMode`, and `EnableGlowEffect`.                                                                              |
| Event Notifications                | Events such as `ValueChanged`, `ValueHasChanged`, `AnimationCompleted`, and `PropertyChanged` inform the host application of gauge updates.                             |
| Integration and Customization      | Leverage these features to enhance interactivity and data binding, while carefully managing performance and event subscriptions.                                        |
| Best Practices and Troubleshooting | Use events to drive UI updates, enable interactive features selectively, and monitor performance when dynamic effects are active.                                       |

***

### Integration Demo

Below is a complete sample code snippet to demonstrate how to integrate and customize the Additional Features & Events into a WinForms application:

```csharp
using System;
using System.Drawing;
using System.Windows.Forms;
using SiticoneNetFrameworkUI;  // Use the namespace from your provided code

public class AdditionalFeaturesDemoForm : Form
{
    private SiticoneGaugeNumeric myGauge;
    private Button toggleInteractivityButton;
    
    public AdditionalFeaturesDemoForm()
    {
        // Initialize the gauge with additional features and events enabled
        myGauge = new SiticoneGaugeNumeric
        {
            MinValue = 0f,
            MaxValue = 100f,
            Value = 50f,
            AnimationSpeed = 5f,
            ShowAnimation = true,
            Size = new Size(300, 300),
            Location = new Point(50, 30),
            
            // Enable additional customization features
            EnableDynamicLighting = true,
            InteractiveMode = true,
            EnableGlowEffect = true
        };
        
        // Subscribe to events
        myGauge.ValueChanged += (s, e) =>
        {
            Console.WriteLine("Gauge value changed to: " + myGauge.Value);
        };
        myGauge.AnimationCompleted += (s, e) =>
        {
            Console.WriteLine("Gauge animation completed.");
        };
        myGauge.PropertyChanged += (s, e) =>
        {
            Console.WriteLine("Property changed: " + e.PropertyName);
        };
        
        // Button to toggle interactivity for demonstration purposes
        toggleInteractivityButton = new Button
        {
            Text = "Toggle Interactivity",
            Location = new Point(50, 350),
            Width = 150
        };
        toggleInteractivityButton.Click += (s, e) =>
        {
            myGauge.InteractiveMode = !myGauge.InteractiveMode;
            MessageBox.Show("Interactive mode is now " + (myGauge.InteractiveMode ? "enabled" : "disabled") + ".");
            myGauge.Invalidate();
        };
        
        // Add controls to the form
        Controls.Add(myGauge);
        Controls.Add(toggleInteractivityButton);
    }
    
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.Run(new AdditionalFeaturesDemoForm());
    }
}
```

***

### API Reference

<table><thead><tr><th width="242">Member</th><th width="100">Type</th><th>Description</th></tr></thead><tbody><tr><td>EnableDynamicLighting</td><td>bool</td><td>Enables or disables dynamic lighting effects on the gauge.</td></tr><tr><td>InteractiveMode</td><td>bool</td><td>Enables or disables mouse interaction for modifying the gauge value.</td></tr><tr><td>EnableGlowEffect</td><td>bool</td><td>Enables or disables the glow (or neon) effect on the gauge.</td></tr><tr><td>ValueChanged</td><td>event</td><td>Occurs when the gauge value changes.</td></tr><tr><td>ValueHasChanged</td><td>event</td><td>Occurs when the gauge value has changed, providing previous and new values via event args.</td></tr><tr><td>AnimationCompleted</td><td>event</td><td>Occurs when a gauge value animation completes.</td></tr><tr><td>PropertyChanged</td><td>event</td><td>Standard event that notifies subscribers when a property value changes.</td></tr></tbody></table>

***

This documentation provides a thorough guide for integrating and using the Additional Features & Events group in your WinForms applications. Use the provided examples, tables, and best practices to enable dynamic visual effects, interactive updates, and event notifications that enhance overall application responsiveness and user engagement.
