# Behavior and Interaction

## Overview

The Behavior & Interaction feature enables developers to configure how the SiticoneMenuButton responds to user input. It includes settings for making the button read-only, toggling between menu and X icons upon clicking, and providing feedback through shake and beep effects when interactions are not permitted. This ensures that the control can adapt to various application contexts, providing appropriate interactive cues.

***

### Feature Details

The table below summarizes the key behavior and interaction properties:

| Property           | Data Type | Default Value                            | Description                                                                                                |
| ------------------ | --------- | ---------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| IsReadOnly         | bool      | false                                    | Determines if the button is read-only; when true, user clicks trigger feedback without performing actions. |
| AllowDynamicSwitch | bool      | true                                     | Allows the button to switch between the menu icon and the X icon when clicked.                             |
| IsOpened           | bool      | false                                    | Indicates whether the menu is in the opened (X icon) or closed (menu lines) state.                         |
| CanShake           | bool      | true                                     | Enables a shaking animation as feedback when the button is read-only and clicked.                          |
| CanBeep            | bool      | true                                     | Enables a beep sound as auditory feedback when the button is read-only and clicked.                        |
| Cursor             | Cursor    | Cursors.Hand / Cursors.No (if read-only) | Automatically adjusts the cursor to indicate interactivity or a read-only state.                           |

***

### Code Examples and Samples

Below are several code examples demonstrating how to integrate and customize the behavior and interaction features of the SiticoneMenuButton in a .NET WinForms application.

#### Sample Code: Configuring Read-Only Behavior with Feedback

This example shows how to configure the button to be read-only so that clicking it produces a shake animation and a beep sound rather than performing its normal action.

```csharp
using System;
using System.Drawing;
using System.Windows.Forms;
using SiticoneNetFrameworkUI; // Ensure you reference the correct namespace

namespace ReadOnlyBehaviorDemo
{
    public class MainForm : Form
    {
        private SiticoneMenuButton menuButton;
        private CheckBox chkIsReadOnly;

        public MainForm()
        {
            InitializeComponents();
        }

        private void InitializeComponents()
        {
            // Configure the SiticoneMenuButton for read-only behavior
            menuButton = new SiticoneMenuButton
            {
                Size = new Size(60, 60),
                Location = new Point(50, 50),
                IsReadOnly = true, // Set button to read-only
                CanShake = true,   // Enable shaking animation feedback
                CanBeep = true     // Enable beep sound feedback
            };

            // Checkbox to toggle the read-only state dynamically
            chkIsReadOnly = new CheckBox
            {
                Text = "Read-Only Mode",
                Location = new Point(50, 130),
                Checked = menuButton.IsReadOnly
            };
            chkIsReadOnly.CheckedChanged += (s, e) =>
            {
                menuButton.IsReadOnly = chkIsReadOnly.Checked;
                // Update the cursor based on the read-only state
                menuButton.Cursor = menuButton.IsReadOnly ? Cursors.No : Cursors.Hand;
                menuButton.Invalidate();
            };

            Controls.Add(menuButton);
            Controls.Add(chkIsReadOnly);

            Text = "Read-Only Behavior Demo";
            Size = new Size(300, 250);
            StartPosition = FormStartPosition.CenterScreen;
        }

        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.Run(new MainForm());
        }
    }
}
```

#### Sample Code: Dynamic Icon Switching and Interaction

This example demonstrates how to use the AllowDynamicSwitch and IsOpened properties to toggle between the menu and X icons. It also shows how the button behaves differently in interactive mode.

```csharp
using System;
using System.Drawing;
using System.Windows.Forms;
using SiticoneNetFrameworkUI;

namespace DynamicSwitchDemo
{
    public class MainForm : Form
    {
        private SiticoneMenuButton menuButton;
        private Button btnToggleReadOnly;

        public MainForm()
        {
            InitializeComponents();
        }

        private void InitializeComponents()
        {
            // Configure the SiticoneMenuButton with dynamic icon switching
            menuButton = new SiticoneMenuButton
            {
                Size = new Size(60, 60),
                Location = new Point(40, 40),
                AllowDynamicSwitch = true, // Enable dynamic switch between menu and X icon
                IsOpened = false,          // Initially display menu icon
                IsReadOnly = false         // Button is interactive by default
            };

            // Button to toggle the read-only mode for demonstration purposes
            btnToggleReadOnly = new Button
            {
                Text = "Toggle Read-Only",
                Location = new Point(40, 120),
                Size = new Size(120, 30)
            };
            btnToggleReadOnly.Click += (s, e) =>
            {
                menuButton.IsReadOnly = !menuButton.IsReadOnly;
                menuButton.Cursor = menuButton.IsReadOnly ? Cursors.No : Cursors.Hand;
                menuButton.Invalidate();
            };

            Controls.Add(menuButton);
            Controls.Add(btnToggleReadOnly);

            Text = "Dynamic Icon & Interaction Demo";
            Size = new Size(300, 250);
            StartPosition = FormStartPosition.CenterScreen;
        }

        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.Run(new MainForm());
        }
    }
}
```

#### Sample Code: Combining Feedback with Dynamic Interaction

This sample demonstrates a scenario where the button's behavior dynamically changes based on its state, switching icons on click while providing appropriate feedback when in read-only mode.

```csharp
using System;
using System.Drawing;
using System.Windows.Forms;
using SiticoneNetFrameworkUI;

namespace CombinedBehaviorDemo
{
    public class MainForm : Form
    {
        private SiticoneMenuButton menuButton;
        private CheckBox chkDynamicSwitch;

        public MainForm()
        {
            InitializeComponents();
        }

        private void InitializeComponents()
        {
            // Configure the button with dynamic switching and feedback
            menuButton = new SiticoneMenuButton
            {
                Size = new Size(60, 60),
                Location = new Point(50, 50),
                IsReadOnly = false,
                AllowDynamicSwitch = true,
                IsOpened = false,
                CanShake = true,
                CanBeep = true
            };

            // Checkbox to enable/disable dynamic icon switching
            chkDynamicSwitch = new CheckBox
            {
                Text = "Enable Dynamic Switch",
                Location = new Point(50, 130),
                Checked = menuButton.AllowDynamicSwitch
            };
            chkDynamicSwitch.CheckedChanged += (s, e) =>
            {
                menuButton.AllowDynamicSwitch = chkDynamicSwitch.Checked;
                menuButton.Invalidate();
            };

            Controls.Add(menuButton);
            Controls.Add(chkDynamicSwitch);

            Text = "Combined Behavior Demo";
            Size = new Size(300, 250);
            StartPosition = FormStartPosition.CenterScreen;
        }

        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.Run(new MainForm());
        }
    }
}
```

***

### Key Points

| Aspect                   | Details                                                                                                      |
| ------------------------ | ------------------------------------------------------------------------------------------------------------ |
| User Feedback            | Provides visual (shake) and auditory (beep) feedback when the control is in a read-only state.               |
| Dynamic Interactivity    | Supports toggling between menu and X icons through the AllowDynamicSwitch and IsOpened properties.           |
| State-Dependent Behavior | Changes the cursor and interaction modes based on the IsReadOnly state to clearly communicate interactivity. |

***

### Best Practices

| Practice                            | Explanation                                                                                                               |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| Set Appropriate Read-Only States    | Use the IsReadOnly property to disable interaction in contexts where changes should not occur, ensuring consistency.      |
| Provide Clear Feedback              | Enable CanShake and CanBeep to inform users when an action is not permitted, but avoid excessive or distracting feedback. |
| Use Dynamic Switching Intelligently | Toggle the AllowDynamicSwitch property only when it makes sense in the application context to avoid confusing the user.   |
| Update Cursor Appropriately         | Always update the Cursor property based on the control state to enhance usability and indicate interactivity clearly.     |

***

### Common Pitfalls

| Pitfall                               | How to Avoid                                                                                                                 |
| ------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Inadequate Feedback in Read-Only Mode | Ensure that both visual and auditory feedback (shake and beep) are enabled when the button is set to read-only.              |
| Overuse of Dynamic Switching          | Avoid unnecessary toggling of the IsOpened property, which may confuse users about the current state of the button.          |
| Neglecting to Refresh the Control     | Always call Invalidate() after modifying behavior-related properties to ensure the UI reflects the current state accurately. |

***

### Usage Scenarios

| Scenario                            | How Behavior & Interaction Helps                                                                             |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------------ |
| Secure or Limited Interaction Modes | Use IsReadOnly to disable changes when the button should not trigger actions, providing clear feedback.      |
| Context-Sensitive UI                | Dynamically switch between menu and X icons with AllowDynamicSwitch and IsOpened to match user interactions. |
| Interactive Feedback in Forms       | Provide immediate auditory and visual cues (shake, beep) when user actions are restricted or denied.         |

***

### Review

The Behavior & Interaction feature of the SiticoneMenuButton control is essential for managing user inputs and ensuring that interactions are intuitive and state-appropriate. By using properties such as IsReadOnly, AllowDynamicSwitch, IsOpened, CanShake, and CanBeep, developers can finely tune the control's responsiveness and feedback, ensuring a consistent and effective user experience across different application scenarios.

***

### Summary

The Behavior & Interaction feature empowers developers to control the SiticoneMenuButton’s interactive states and feedback mechanisms. With configurable options to toggle between interactive and read-only modes, dynamically switch icons, and provide both visual and auditory feedback, this feature ensures that the button behaves appropriately within the application context, enhancing both usability and user experience.

***

### Additional Sections

#### Troubleshooting

| Issue                                             | Resolution                                                                                                          |
| ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| Button Not Responding to Clicks in Read-Only Mode | Verify that IsReadOnly is correctly set and that CanShake/CanBeep are enabled to provide feedback on user clicks.   |
| Dynamic Icon Switching Not Working                | Ensure that AllowDynamicSwitch is set to true and that Invalidate() is called after toggling the IsOpened property. |
| Cursor Not Updating                               | Check that the Cursor property is updated in accordance with the IsReadOnly state.                                  |

#### Future Enhancements

| Enhancement                   | Description                                                                                                             |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| Customizable Feedback Effects | Allow developers to customize the intensity and duration of shake and beep effects to better match application themes.  |
| Advanced Interaction Modes    | Introduce additional states or transitions (e.g., hover states for read-only buttons) to further enhance interactivity. |

By following this documentation, developers can effectively implement and customize the Behavior & Interaction features of the SiticoneMenuButton control, ensuring that it responds appropriately to user inputs and maintains a consistent interactive experience across various application scenarios.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs-siticoneframework.gitbook.io/home/net-framework-or-net-core-ui/buttons-and-elements/siticone-menubutton/behavior-and-interaction.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.