# Context Menu Customization

## Overview

The Context Menu Customization feature in the SiticoneTabControl provides a built‐in right‐click context menu that offers operations such as closing a tab, closing other tabs, and pinning/unpinning tabs (if enabled). Developers can customize the menu’s font and behavior to seamlessly integrate common tab operations with the overall application design.

***

### Properties Overview

| Property Name   | Description                                                                          | Default Value           | Data Type |
| --------------- | ------------------------------------------------------------------------------------ | ----------------------- | --------- |
| ContextMenuFont | Sets the font used for the items in the right‐click context menu of the tab control. | Segoe UI, 10pt, Regular | Font      |

\*Note: The actual context menu items and their behaviors are defined internally and are based on the state of properties such as AllowPinning and CanCloseTab.

***

### Key Points

| Aspect                  | Details                                                                                                                                                |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Integrated Operations   | The context menu offers built‐in commands for common operations (e.g., Close, Close Others, Close Tabs to Right, Pin/Unpin) without additional coding. |
| Dynamic Behavior        | Menu items adapt dynamically based on the state of the tab (e.g., if a tab is closable or pinned) ensuring the options remain contextually relevant.   |
| Customizable Appearance | The font of the context menu is customizable via the ContextMenuFont property, allowing for consistent visual styling with the application.            |

***

### Best Practices

| Practice                               | Explanation                                                                                                                        | Code Example                                                                                                         |
| -------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| Customize the Menu Font                | Use the ContextMenuFont property to match the context menu's appearance with the rest of your application's UI.                    | `csharp<br>tabControl.ContextMenuFont = new Font("Segoe UI", 10, FontStyle.Regular);<br>`                            |
| Enable Context Menu for Key Operations | Ensure that only necessary operations (e.g., close operations on closable tabs) are enabled to avoid overwhelming the user.        | `csharp<br>// Mark a tab as closable so the Close options appear<br>tabControl.CanCloseTab[someTabPage] = true;<br>` |
| Maintain Consistent Menu Behavior      | Verify that the context menu correctly reflects the current state of a tab (for example, showing "Pin" or "Unpin" as appropriate). | `csharp<br>// The menu automatically adjusts the text based on the tab's pinned state<br>`                           |

***

### Common Pitfalls

| Pitfall                                       | Explanation                                                                                                           | How to Avoid                                                                   |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
| Inconsistent Font Appearance                  | Failing to set the ContextMenuFont property may result in a context menu that does not match the application’s theme. | Explicitly assign a consistent font to ContextMenuFont.                        |
| Menu Options Not Reflecting Tab State         | If tabs are not marked correctly as closable or pinned, the context menu may display options that are not applicable. | Use the CanCloseTab and Pinned collections appropriately for each tab.         |
| Overloading the Menu with Unnecessary Options | Adding too many operations can clutter the context menu, confusing the user.                                          | Keep the context menu focused on key operations such as close and pin actions. |

***

### Usage Scenarios

| Scenario                      | Description                                                                                                                                             | Sample Code Snippet                                                                                                      |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| Enabling Quick Tab Closure    | For applications that allow users to close tabs, marking tabs as closable will display a “Close” option in the context menu.                            | `csharp<br>// Mark a tab as closable<br>tabControl.CanCloseTab[someTabPage] = true;<br>`                                 |
| Allowing Pin/Unpin Operations | When pinning is enabled (AllowPinning = true), the context menu will display a dynamic “Pin/Unpin” option for managing tabs.                            | `csharp<br>tabControl.AllowPinning = true;<br>// The context menu will then offer a Pin/Unpin option automatically.<br>` |
| Simplifying Tab Management    | In multi-tab interfaces, providing options like “Close Others” and “Close Tabs to Right” via the context menu helps users manage open tabs efficiently. | `csharp<br>// These options appear automatically for tabs marked as closable<br>`                                        |

***

### Detailed Code Examples

#### Example 1: Basic Context Menu Customization

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

public class ContextMenuDemoForm : Form
{
    private SiticoneTabControl tabControl;

    public ContextMenuDemoForm()
    {
        InitializeComponents();
    }

    private void InitializeComponents()
    {
        // Create the SiticoneTabControl and configure the context menu font.
        tabControl = new SiticoneTabControl
        {
            Location = new Point(20, 20),
            Size = new Size(700, 350),
            ContextMenuFont = new Font("Segoe UI", 10, FontStyle.Regular)
        };

        // Optionally enable pinning and closable tabs for full context menu options.
        tabControl.AllowPinning = true;

        // Add sample tabs.
        for (int i = 0; i < 4; i++)
        {
            TabPage page = new TabPage($"Tab {i + 1}");
            // Mark even-numbered tabs as closable.
            if (i % 2 == 0)
            {
                tabControl.CanCloseTab[page] = true;
            }
            tabControl.TabPages.Add(page);
        }

        // Add the tab control to the form.
        this.Controls.Add(tabControl);
        this.Text = "Context Menu Customization Demo";
        this.StartPosition = FormStartPosition.CenterScreen;
    }

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

#### Example 2: Dynamic Context Menu Behavior with Pinning

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

public class DynamicContextMenuForm : Form
{
    private SiticoneTabControl tabControl;
    private Button togglePinButton;

    public DynamicContextMenuForm()
    {
        InitializeComponents();
    }

    private void InitializeComponents()
    {
        // Initialize the tab control with pinning enabled.
        tabControl = new SiticoneTabControl
        {
            Dock = DockStyle.Top,
            Height = 250,
            ContextMenuFont = new Font("Segoe UI", 10, FontStyle.Regular),
            AllowPinning = true
        };

        // Add sample tabs.
        for (int i = 0; i < 3; i++)
        {
            TabPage page = new TabPage($"Page {i + 1}");
            // Mark the first tab as closable.
            tabControl.CanCloseTab[page] = true;
            tabControl.TabPages.Add(page);
        }

        // Button to simulate dynamic changes (e.g., toggling the pinned state via context menu would occur automatically).
        togglePinButton = new Button
        {
            Text = "Simulate Pin Toggle on Page 1",
            Dock = DockStyle.Bottom,
            Height = 40
        };
        togglePinButton.Click += (s, e) =>
        {
            // Toggle the pin state of the first tab.
            TabPage firstPage = tabControl.TabPages[0];
            bool currentState = tabControl.Pinned[firstPage];
            tabControl.Pinned[firstPage] = !currentState;
            MessageBox.Show($"Page 1 is now {(tabControl.Pinned[firstPage] ? "pinned" : "unpinned")}.", "Pin Toggle");
        };

        this.Controls.Add(tabControl);
        this.Controls.Add(togglePinButton);
        this.Text = "Dynamic Context Menu Demo";
        this.StartPosition = FormStartPosition.CenterScreen;
    }

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

***

### Review

| Aspect                         | Review Comments                                                                                                                            |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
| Ease of Integration            | The context menu is integrated within the control, and key operations are available out-of-the-box with minimal configuration.             |
| Dynamic and Contextual Options | Menu items adapt based on tab state (e.g., displaying "Pin" or "Unpin", showing close options only for closable tabs), ensuring relevance. |
| Consistent Appearance          | Customization via ContextMenuFont ensures that the context menu blends well with the application’s overall visual design.                  |

***

### Summary

The Context Menu Customization feature in the SiticoneTabControl provides an integrated, dynamic right‐click menu that simplifies common tab operations such as closing, closing others, and pinning/unpinning tabs. Developers can adjust the menu’s appearance using the ContextMenuFont property, while the control’s internal logic ensures that menu options are displayed contextually based on the state of each tab. This feature enhances usability by offering quick access to essential tab management operations without additional coding effort.

***

### Additional Sections

#### Integration Checklist

| Step                         | Action Required                                                                                                                              |
| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| Instantiate the Control      | Create an instance of SiticoneTabControl and add it to your form.                                                                            |
| Set the Context Menu Font    | Assign a consistent font to the ContextMenuFont property to match your application's theme.                                                  |
| Enable Key Features          | Configure AllowPinning and mark tabs as closable using the CanCloseTab collection as needed.                                                 |
| Test Context Menu Operations | Verify that right-clicking on a tab shows the appropriate options (e.g., Pin/Unpin, Close, Close Others) and that they function as expected. |
| Validate Dynamic Behavior    | Confirm that the context menu items adjust dynamically based on the state of each tab.                                                       |

#### Frequently Asked Questions

| Question                                           | Answer                                                                                                                                                     |
| -------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| How do I customize the font in the context menu?   | Use the ContextMenuFont property to set the desired font for the context menu.                                                                             |
| Can I disable certain context menu options?        | The context menu adapts automatically based on tab properties; ensure tabs are marked correctly (e.g., using CanCloseTab) to control which options appear. |
| What operations are supported by the context menu? | The context menu supports pin/unpin (if AllowPinning is enabled), closing a tab, closing other tabs, and closing tabs to the right.                        |

***

This comprehensive documentation for the Context Menu Customization feature, based solely on the provided code, is designed to guide developers in integrating and customizing the right‐click context menu functionality in their WinForms applications using the SiticoneTabControl.


---

# 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/container-and-layout/siticone-tabcontrol/context-menu-customization.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.