Syncfusion WPF Samples

https://github.com/syncfusion/wpf-demos
Admin
Syncfusion WPF Samples provides demo applications for Syncfusion WPF Controls, offering insights...
Tokens:25,550
Snippets:352
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Initialize NavigationViewModel

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/navigation-view-model.md

Example of instantiating the model with text and icon properties.

```csharp
var navItem = new NavigationViewModel
{
    NavigationItem = "All Controls",
    NavigationIcon = iconPath
};
```

--------------------------------

### Initialize DemoInfo Instance

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/product-demo-models.md

Example of creating and configuring a new DemoInfo instance for a specific sample.

```csharp
var demo = new DemoInfo
{
    SampleName = "DefaultGridDemo",
    Title = "Default Functionality",
    Description = "Demonstrates basic DataGrid features including columns and rows.",
    GroupName = "Selection",
    ControlName = "DataGrid",
    DemoViewType = typeof(DefaultGridView),
    DemoLauchMode = DemoLauchMode.Default,
    ThemeMode = ThemeMode.Inherit,
    Tag = Tag.None,
    ShowBusyIndicator = true,
    Documentations = new List<Documentation>
    {
        new Documentation 
        { 
            Content = "DataGrid Documentation",
            Uri = new Uri("https://help.syncfusion.com/wpf/datagrid/...")
        }
    }
};
```

--------------------------------

### Initialize Themes Instance

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/product-demo-models.md

Example of instantiating the Themes class with specific visual properties.

```csharp
var theme = new Themes
{
    ThemeName = "Windows11Light",
    ThemeType = "Light",
    DisplayName = "Windows 11 Light",
    EllipseFill = new SolidColorBrush(Color.FromRgb(200, 200, 200)),
    EllipseStroke = new SolidColorBrush(Colors.Gray),
    PathFill = new SolidColorBrush(Colors.White)
};
```

--------------------------------

### Implement DataGridProductDemo

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/product-demo-models.md

Example of a concrete implementation of the ProductDemo class for a DataGrid product.

```csharp
// Concrete implementation in specific demo modules
public class DataGridProductDemo : ProductDemo
{
    public DataGridProductDemo()
    {
        Product = "Data Grid";
        ProductCategory = "GRIDS";
        Tag = Tag.None;
        DemoLauchMode = DemoLauchMode.Default;
        Demos = new List<DemoInfo> { /* ... */ };
    }
}
```

--------------------------------

### ViewModel and Application Startup Setup

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-launcher.md

Defines the demo browser view model and initializes the main window context during application startup.

```csharp
public class SampleBrowserViewModel : DemoBrowserViewModel
{
    public override List<ProductDemo> GetDemosDetails()
    {
        return new List<ProductDemo>
        {
            new DataGridProductDemo(),
            new ChartProductDemo(),
            // ... more products
        };
    }
}

// Application startup
public partial class App : Application
{
    private void Application_Startup(object sender, StartupEventArgs e)
    {
        DemosNavigationService.MainWindow = MainWindow;
        MainWindow.DataContext = new SampleBrowserViewModel();
        MainWindow.Show();
    }
}
```

--------------------------------

### Initialize BaseCommand Instance

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/mvvm-commands.md

Example of creating a new BaseCommand instance with specific execution and condition delegates.

```csharp
var saveCommand = new BaseCommand(
    execute: (param) => SaveFile(),
    canExecute: (param) => HasUnsavedChanges()
);
```

--------------------------------

### Configure GridLength for DemoControl

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/types.md

Examples of setting the OptionsSize property using different GridLength configurations.

```csharp
// Fixed 300-pixel width
demoControl.OptionsSize = new GridLength(300);

// Proportional 1:2 ratio
demoControl.OptionsSize = new GridLength(2, GridUnitType.Star);

// Size to content
demoControl.OptionsSize = new GridLength(0, GridUnitType.Auto);
```

--------------------------------

### DelegateCommand CanExecute and Execute Usage

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/mvvm-commands.md

Example of checking executability before invoking a non-generic command.

```csharp
var command = new DelegateCommand(
    executeAction: (param) => ProcessData(param),
    canExecute: (param) => param != null
);

if (command.CanExecute(data)) {
    command.Execute(data);
}
```

--------------------------------

### Set OptionsPosition using Dock

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/types.md

Example of positioning the options panel on the left side of a DemoControl.

```xml
<!-- Position options panel on left side -->
<local:DemoControl OptionsPosition="Left" OptionsSize="250">
    ...
</local:DemoControl>
```

--------------------------------

### DelegateCommand<T> CanExecute Usage

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/mvvm-commands.md

Example of initializing a generic command with an execution action and a predicate for executability.

```csharp
var command = new DelegateCommand<string>(
    method: (text) => MessageBox.Show(text),
    canExecute: (text) => !string.IsNullOrEmpty(text)
);

bool canRun = command.CanExecute("Hello"); // Returns true if text is not empty
```

--------------------------------

### DockingManager Basic XAML Setup

Source: https://github.com/syncfusion/wpf-demos/blob/master/dockingmanager/Assets/DockingManager/StatePersistence/StatePersistence_xaml.txt

This snippet shows the basic XAML structure for initializing the Syncfusion DockingManager. It includes common properties like AnimationDelay, ContainerMode, and UseDocumentContainer.

```XAML
<syncfusion:DockingManager
            x:Name="dockingManager"
            Grid.Row="1"
            AnimationDelay="00:00:00.03"
            ContainerMode="TDI"
            IsEnableHotTracking="True"
            IsVS2010DraggingEnabled="True"
            PersistState="False"
            UseDocumentContainer="True">
            <!--  Toolbox dock window  -->
            <ContentControl
                Name="Toolbox"
                HorizontalContentAlignment="Left"
                syncfusion:DockingManager.DesiredWidthInDockedMode="250"
                syncfusion:DockingManager.Header="Toolbox"
                syncfusion:DockingManager.State="Dock"
                Content="{StaticResource ToolboxGroups}">
                <syncfusion:DockingManager.Icon>
                    <ImageBrush ImageSource="..\Assets\DockingManager\Toolbox.png" />
                </syncfusion:DockingManager.Icon>
            </ContentControl>


            <!--  Docking dock window  -->
            <ContentControl
                Name="Docking"
                syncfusion:DockingManager.Header="MainWindow.xaml"
                syncfusion:DockingManager.State="Document">
                <syncfusion:EditControl
                    x:Name="codeText1"
                    DocumentLanguage="XAML"
                    FontFamily="Segoe UI"
                    FontSize="12"
                    Foreground="#FF1E1E1E" />
            </ContentControl>


            <!--  Features dock window  -->
            <ContentControl
                Name="Features"
                syncfusion:DockingManager.Header="MainWindow.xaml.cs"
                syncfusion:DockingManager.State="Document">
                <syncfusion:EditControl
                    x:Name="codeText"
                    DocumentLanguage="CSharp"
                    FontFamily="Segoe UI"
                    FontSize="12"
                    Foreground="#FF1E1E1E" />
            </ContentControl>

            <!--  SolutionExplorer dock window  -->
            <ContentControl
                Name="SolutionExplorer"
                syncfusion:DockingManager.DesiredWidthInDockedMode="300"
                syncfusion:DockingManager.Header="Solution Explorer"
                syncfusion:DockingManager.SideInDockedMode="Right"
                Content="{StaticResource SolutionExplorerTree}">
                <syncfusion:DockingManager.Icon>
                    <ImageBrush ImageSource="..\Assets\DockingManager\Solution.png" />
                </syncfusion:DockingManager.Icon>
            </ContentControl>

            <!--  FindResults dock window  -->
            <ContentControl
                Name="Properties"
                syncfusion:DockingManager.Header="Properties"
                syncfusion:DockingManager.SideInDockedMode="Tabbed"
                syncfusion:DockingManager.TargetNameInDockedMode="SolutionExplorer">
                <syncfusion:DockingManager.Icon>
                    <ImageBrush ImageSource="..\Assets\DockingManager\Properties.png" />
                </syncfusion:DockingManager.Icon>
                <syncfusion:PropertyGrid
                    x:Name="prop"
                    Margin="0"
                    HorizontalAlignment="Stretch"
                    VerticalAlignment="Stretch"
                    BorderThickness="0"
                    DefaultPropertyPath="Content"
                    DescriptionPanelVisibility="Collapsed"
                    EnableGrouping="True">
                    <syncfusion:PropertyGrid.SelectedObject>
                        <local:Person />
                    </syncfusion:PropertyGrid.SelectedObject>

                </syncfusion:PropertyGrid>
            </ContentControl>
        </syncfusion:DockingManager>
```

--------------------------------

### DelegateCommand<T> Execute Usage

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/mvvm-commands.md

Example of invoking the Execute method on a generic command.

```csharp
var command = new DelegateCommand<int>(
    (count) => { /* process count */ }
);
command.Execute(42);
```

--------------------------------

### SubCategoryDemos

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Gets or sets the hierarchical child demos for multi-level sample organization.

```APIDOC
## SubCategoryDemos

### Description
Hierarchical child demos for multi-level sample organization.

### Type
List<DemoInfo>

### Default
null
```

--------------------------------

### Bind Navigation Data in XAML

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/navigation-view-model.md

Examples of binding NavigationViewModel collections to ItemsControl and ListBox elements.

```xml
<ItemsControl ItemsSource="{Binding NavigationItems}">
    <ItemsControl.ItemTemplate>
        <DataTemplate>
            <StackPanel Orientation="Horizontal">
                <Path Data="{Binding NavigationIcon}" />
                <TextBlock Text="{Binding NavigationItem}" />
            </StackPanel>
        </DataTemplate>
    </ItemsControl.ItemTemplate>
</ItemsControl>
```

```xml
<ListBox ItemsSource="{Binding NavigationItems}"
         SelectedItem="{Binding SelectedNavigationItem}">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <Grid>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="Auto" />
                    <ColumnDefinition Width="*" />
                </Grid.ColumnDefinitions>
                
                <Image Grid.Column="0" 
                       Source="{Binding NavigationIcon}"
                       Width="24" Height="24" />
                
                <TextBlock Grid.Column="1" 
                           Text="{Binding NavigationItem}"
                           Margin="10,0,0,0"
                           VerticalAlignment="Center" />
            </Grid>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>
```

--------------------------------

### Initialize Documentation model

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/product-demo-models.md

Create a new instance of the Documentation class to define a help link with display text and a URI.

```csharp
var doc = new Documentation
{
    Content = "Getting Started Guide",
    Uri = new Uri("https://help.syncfusion.com/wpf/datagrid/getting-started")
};
```

--------------------------------

### SubCategorySelectedItem

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Gets or sets the currently selected child demo from SubCategoryDemos.

```APIDOC
## SubCategorySelectedItem

### Description
Currently selected child demo from SubCategoryDemos.

### Type
DemoInfo

### Default
null
```

--------------------------------

### Launch a demo with theme support

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-launcher.md

Demonstrates defining a view with theme-aware constructors and invoking it via DemoLauncherExtension.

```csharp
public class DataGridDemoView : UserControl
{
    // Constructor supporting theme parameter (preferred)
    public DataGridDemoView() { }
    public DataGridDemoView(string themename)
    {
        InitializeComponent();
        SfSkinManager.SetTheme(this, Theme.GetTheme(themename));
    }
}

// Launch demo
var demoInfo = new DemoInfo
{
    DemoViewType = typeof(DataGridDemoView),
    ThemeMode = ThemeMode.Inherit
};

var demo = DemoLauncherExtension.LauchDemo<UserControl>(viewModel, demoInfo);
```

--------------------------------

### OptionsVerticalScrollBarVisibility

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Gets or sets the vertical scrollbar behavior in the options panel.

```APIDOC
## OptionsVerticalScrollBarVisibility

### Description
Vertical scrollbar behavior in options panel.

### Type
ScrollBarVisibility

### Default
ScrollBarVisibility.Disabled

### Example
```xml
<local:DemoControl OptionsVerticalScrollBarVisibility="Auto">
    ...
</local:DemoControl>
```
```

--------------------------------

### OptionsHorizontalScrollBarVisibility

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Gets or sets the horizontal scrollbar behavior in the options panel.

```APIDOC
## OptionsHorizontalScrollBarVisibility

### Description
Horizontal scrollbar behavior in options panel.

### Type
ScrollBarVisibility

### Default
ScrollBarVisibility.Disabled

### Example
```xml
<local:DemoControl OptionsHorizontalScrollBarVisibility="Auto">
    ...
</local:DemoControl>
```
```

--------------------------------

### Initialize ProductInfo model

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/product-demo-models.md

Create a new instance of the ProductInfo class to aggregate demo metadata.

```csharp
var productInfo = new ProductInfo
{
    SampleName = "DefaultDataGridDemo",
    ProductDemo = dataGridProductDemo,
    ProductDemoInfo = defaultGridDemoInfo
};
```

--------------------------------

### HyperLinkStyle

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Gets or sets the Style applied to hyperlinks in the documentation list.

```APIDOC
## HyperLinkStyle

### Description
Style applied to hyperlinks in documentation list. Allows customization of link appearance.

### Type
Style

### Default
null

### Example
```xml
<local:DemoControl HyperLinkStyle="{StaticResource DocumentationLinkStyle}">
    ...
</local:DemoControl>
```
```

--------------------------------

### Implement Demo View Theme Support

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/configuration.md

Use the preferred constructor-based approach for theme injection or the fallback post-instantiation method.

```csharp
public class MyDemoView : UserControl
{
    public MyDemoView() { }
    public MyDemoView(string themename)
    {
        InitializeComponent();
        SfSkinManager.SetTheme(this, Theme.GetTheme(themename));
    }
}
```

```csharp
public class MyDemoView : UserControl
{
    public MyDemoView()
    {
        InitializeComponent();
    }
}

// Theme applied after instantiation
SfSkinManager.SetTheme(demoControl, Theme.GetTheme(themeName));
```

--------------------------------

### Implement Application Startup Pattern

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/configuration.md

Initializes application-wide settings, navigation services, and the main ViewModel during the Application_Startup event.

```csharp
public partial class App : Application
{
    private void Application_Startup(object sender, StartupEventArgs e)
    {
        // Set application-wide configuration before creating ViewModel
        DemoBrowserViewModel.HeaderTitleText = "Syncfusion WPF Demos";
        DemoBrowserViewModel.DefaultThemeName = "Windows11Light";
        DemoBrowserViewModel.IsMainSB = true;
        
        // Initialize navigation service
        DemosNavigationService.MainWindow = MainWindow;
        
        // Create and set ViewModel
        var viewModel = new SampleBrowserViewModel();
        MainWindow.DataContext = viewModel;
        
        MainWindow.Show();
    }
}
```

--------------------------------

### Define a Product Demo Class

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/product-demo-models.md

Inherit from ProductDemo to define product metadata and register a collection of demo samples.

```csharp
public class ChartProductDemo : ProductDemo
{
    public ChartProductDemo()
    {
        Product = "Chart";
        ProductCategory = "CHARTS";
        ControlDescription = "Chart control for data visualization";
        Tag = Tag.None;
        DemoLauchMode = DemoLauchMode.Default;
        
        Demos = new List<DemoInfo>
        {
            new DemoInfo
            {
                SampleName = "LineChart",
                Title = "Line Chart",
                Description = "Basic line chart with data points",
                GroupName = "Basic Charts",
                ControlName = "Chart",
                DemoViewType = typeof(LineChartView),
                ThemeMode = ThemeMode.Inherit,
                Tag = Tag.None,
                ShowBusyIndicator = true,
                Documentations = new List<Documentation>
                {
                    new Documentation
                    {
                        Content = "Chart Documentation",
                        Uri = new Uri("https://help.syncfusion.com/wpf/chart/...")
                    }
                }
            }
        };
    }
}
```

--------------------------------

### Configure Demo Window Properties

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-launcher.md

Sets the title, owner, and startup location for a demo window before displaying it modally.

```csharp
window.Title = viewmodel.SelectedSample.Title;
window.Owner = DemosNavigationService.MainWindow;
window.WindowStartupLocation = WindowStartupLocation.CenterScreen;
window.Closed += Window_Closed;
window.ShowDialog();
```

--------------------------------

### DelegateCommand<T> RaiseCanExecuteChanged Usage

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/mvvm-commands.md

Example of manually triggering a notification for command state changes.

```csharp
// After business logic updates eligibility
command.RaiseCanExecuteChanged();
```

--------------------------------

### Define Product and Demo Metadata in C#

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/configuration.md

Configures product details, status flags, and a list of demo views for the Data Grid control.

```csharp
public class DataGridProductDemo : ProductDemo
{
    public DataGridProductDemo()
    {
        // Metadata
        Product = "Data Grid";
        ProductCategory = "GRIDS";
        ControlDescription = "High-performance data grid for tabular data display";
        
        // Status
        Tag = Tag.None;
        IsPreview = false;
        IsHighlighted = true;
        
        // Behavior
        DemoLauchMode = DemoLauchMode.Default;
        
        // Demos
        Demos = new List<DemoInfo>
        {
            new DemoInfo
            {
                SampleName = "DefaultGrid",
                Title = "Default Functionality",
                GroupName = "Getting Started",
                DemoViewType = typeof(DefaultDataGridView),
                ThemeMode = ThemeMode.Inherit,
                ShowBusyIndicator = true,
                Tag = Tag.None
            },
            new DemoInfo
            {
                SampleName = "AdvancedGrid",
                Title = "Advanced Features",
                GroupName = "Advanced",
                DemoViewType = typeof(AdvancedDataGridView),
                ThemeMode = ThemeMode.Inherit,
                ShowBusyIndicator = true,
                Tag = Tag.Updated
            }
        };
    }
}
```

--------------------------------

### DocumentsItemSource

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Gets or sets the ItemsSource for documentation links, typically a collection of Documentation objects.

```APIDOC
## DocumentsItemSource

### Description
Gets or sets the ItemsSource for documentation links. Typically a List<Documentation> collection.

### Type
object

### Default
null

### Example
```csharp
demoControl.DocumentsItemSource = new List<Documentation>
{
    new Documentation 
    { 
        Content = "API Reference",
        Uri = new Uri("https://help.syncfusion.com/wpf/datagrid/api/...")
    },
    new Documentation
    {
        Content = "Getting Started",
        Uri = new Uri("https://help.syncfusion.com/wpf/datagrid/getting-started")
    }
};
```
```

--------------------------------

### Implement a custom DemoBrowserViewModel

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/sample-browser-viewmodel.md

Override GetDemosDetails to register product demos and hook into sample or theme change events.

```csharp
public class DataGridSampleBrowserViewModel : DemoBrowserViewModel
{
    public override List<ProductDemo> GetDemosDetails()
    {
        return new List<ProductDemo>
        {
            new DataGridProductDemo
            {
                Product = "Data Grid",
                ProductCategory = "GRIDS",
                Demos = new List<DemoInfo>
                {
                    new DemoInfo
                    {
                        SampleName = "DefaultDataGrid",
                        Title = "Default Functionality",
                        Description = "Shows basic DataGrid features",
                        GroupName = "Getting Started",
                        ControlName = "SfDataGrid",
                        DemoViewType = typeof(DefaultDataGridView),
                        ThemeMode = ThemeMode.Inherit,
                        ShowBusyIndicator = true
                    },
                    new DemoInfo
                    {
                        SampleName = "SelectionDataGrid",
                        Title = "Selection Modes",
                        Description = "Demonstrates different selection behaviors",
                        GroupName = "Selection",
                        ControlName = "SfDataGrid",
                        DemoViewType = typeof(SelectionDataGridView),
                        ThemeMode = ThemeMode.Inherit,
                        ShowBusyIndicator = true
                    }
                }
            }
        };
    }

    protected override void OnSelectedSampleChanged(DemoInfo sample)
    {
        base.OnSelectedSampleChanged(sample);
        // Custom logic when sample changes
    }

    protected override void OnThemeChanged(string themeName)
    {
        base.OnThemeChanged(themeName);
        // Custom theme switching logic
    }
}
```

--------------------------------

### Use BoolToObjectConverter in XAML

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/value-converters.md

Example of mapping a boolean property to Visibility states using the converter.

```xml
<!-- XAML: Convert boolean to visibility -->
<BoolToObjectConverter x:Key="BoolVisibilityConverter" 
                       TrueValue="{x:Static Visibility.Visible}" 
                       FalseValue="{x:Static Visibility.Collapsed}" />

<TextBlock Visibility="{Binding IsVisible, Converter={StaticResource BoolVisibilityConverter}}" 
           Text="Shown when IsVisible is true" />
```

--------------------------------

### Initialize NavigationViewModel

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/navigation-view-model.md

Demonstrates the default constructor and basic property assignment.

```csharp
public NavigationViewModel()
{
}
```

```csharp
var navItem = new NavigationViewModel();
navItem.NavigationItem = "Home";
navItem.NavigationIcon = iconSource;
```

--------------------------------

### Initialize DemoControl with Theme

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Apply a specific theme during instantiation.

```csharp
var demo = new DemoControl("Windows11Dark")
{
    Title = "Dark Theme Demo"
};
```

--------------------------------

### DemoLauncherExtension.LauchDemo<T>

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-launcher.md

Instantiates a demo view of type T, applying themes based on the provided DemoInfo and DemoBrowserViewModel.

```APIDOC
## static T LauchDemo<T>(DemoBrowserViewModel viewmodel, DemoInfo demoInfo)

### Description
Instantiates a demo from DemoViewType with optional theme application. The method attempts to use a constructor accepting a theme name string, falling back to a parameterless constructor with SfSkinManager theme application.

### Parameters
- **viewmodel** (DemoBrowserViewModel) - Required - Current demo browser state; provides theme selection.
- **demoInfo** (DemoInfo) - Required - Demo metadata including DemoViewType and ThemeMode.

### Returns
- **T** - Instance of T (DemoViewType cast to T), or null if instantiation fails.

### Example
```csharp
var demoInfo = new DemoInfo
{
    DemoViewType = typeof(DataGridDemoView),
    ThemeMode = ThemeMode.Inherit
};

var demo = DemoLauncherExtension.LauchDemo<UserControl>(viewModel, demoInfo);
```
```

--------------------------------

### Configure Vertical ScrollBarVisibility in XAML

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/types.md

Example of enabling automatic vertical scrolling within a DemoControl.

```xml
<!-- Enable vertical scrolling in options panel -->
<local:DemoControl OptionsVerticalScrollBarVisibility="Auto">
    <local:DemoControl.Options>
        <StackPanel>
            <!-- Many controls here -->
        </StackPanel>
    </local:DemoControl.Options>
</local:DemoControl>
```

--------------------------------

### Initialize DemoControl with Default Settings

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Create a new instance using the default constructor.

```csharp
var demo = new DemoControl
{
    Title = "My Demo",
    ControlName = "DataGrid"
};
```

--------------------------------

### EmptyObjectToObjectConverter XAML Usage

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/value-converters.md

Example of using the converter in XAML to toggle visibility based on object emptiness.

```xml
<!-- Show message when object is null -->
<TextBlock Text="No data available" 
           Visibility="{Binding DataObject, 
           Converter={StaticResource EmptyObjectConverter}, 
           ConverterParameter='true'}" />
```

--------------------------------

### Initialize Navigation Service

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-launcher.md

Defines the static navigation service and its initialization requirement before launching a demo.

```csharp
public static class DemosNavigationService
{
    public static Window MainWindow { get; set; }
```

```csharp
DemosNavigationService.MainWindow = Application.Current.MainWindow;
```

--------------------------------

### Implement GetDemosDetails

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/sample-browser-viewmodel.md

Override the GetDemosDetails method to define the collection of products and demos available in the browser.

```csharp
public class SampleBrowserViewModel : DemoBrowserViewModel
{
    public override List<ProductDemo> GetDemosDetails()
    {
        return new List<ProductDemo>
        {
            new DataGridProductDemo(),
            new ChartProductDemo(),
            new DiagramProductDemo(),
            new SchedulerProductDemo(),
            // ... more products
        };
    }
}
```

--------------------------------

### Initialize DemoBrowserViewModel Constructor

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/sample-browser-viewmodel.md

The constructor initializes command delegates and populates demo collections by calling the abstract GetDemosDetails method.

```csharp
public DemoBrowserViewModel()
```

--------------------------------

### Create ViewModel

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/README.md

Implement the DemoBrowserViewModel to expose your product collection to the demo browser.

```csharp
public class DemoViewModel : DemoBrowserViewModel
{
    public override List<ProductDemo> GetDemosDetails()
    {
        return new List<ProductDemo> { new MyProductDemo() };
    }
}
```

--------------------------------

### XAML Behavior Binding for Demo Launching

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-launcher.md

Configures the UI to trigger demo launching via interaction behaviors bound to a button click.

```xml
<Window x:Class="DemoApplication.MainWindow"
        xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
        xmlns:local="clr-namespace:syncfusion.demoscommon.wpf">
    
    <StackPanel>
        <ListBox ItemsSource="{Binding Products}" 
                 SelectedItem="{Binding SelectedProduct}">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <TextBlock Text="{Binding Product}" />
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
        
        <ListBox ItemsSource="{Binding SelectedProduct.Demos}"
                 SelectedItem="{Binding SelectedSample}">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <TextBlock Text="{Binding Title}" />
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
        
        <Button Content="Launch Demo" Padding="10">
            <i:Interaction.Triggers>
                <i:EventTrigger EventName="Click">
                    <local:LaunchDemoAction />
                </i:EventTrigger>
            </i:Interaction.Triggers>
        </Button>
    </StackPanel>
</Window>
```

--------------------------------

### Load Dock State from Binary with SOAP formatter

Source: https://github.com/syncfusion/wpf-demos/blob/master/dockingmanager/Assets/DockingManager/StatePersistence/StatePersistence_cs.txt

Loads the dock state from a binary file using a SOAP formatter. Includes error handling for XML exceptions.

```csharp
SoapFormatter formatter1 = new SoapFormatter();
try
{
    dockingManager.LoadDockState(formatter1, StorageFormat.Binary, AppDomain.CurrentDomain.BaseDirectory.ToString() + "\\docking_bin_soap.bin");
}
catch (XmlException ex)
{
    MessageBox.Show(ex.Message, AttentionHeader, MessageBoxButton.OK, MessageBoxImage.Warning);
}
```

--------------------------------

### Demo View Theme Support

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-launcher.md

Implements theme application for a UserControl using the SfSkinManager.

```csharp
public partial class DataGridDemoView : UserControl
{
    public DataGridDemoView()
    {
        InitializeComponent();
    }

    public DataGridDemoView(string themename) : this()
    {
        SfSkinManager.SetTheme(this, Theme.GetTheme(themename));
    }
}
```

--------------------------------

### DemoLaunchMode Enumeration

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/types.md

Defines the launch behavior for demo samples within the application.

```csharp
public enum DemoLauchMode
{
    Default = 0,    // Load demo inside sample browser frame
    Window = 1      // Launch demo in separate child window
}
```

--------------------------------

### Handle demo instantiation exceptions in C#

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-launcher.md

Use this try-catch block to reset the busy state and display an error dialog when demo instantiation fails.

```csharp
try
{
    // ... demo instantiation ...
}
catch (Exception exception)
{
    viewmodel.IsProductDemoBusy = false;
    ErrorWindow.Show(exception.Message + "\n" + exception.StackTrace);
}
```

--------------------------------

### Configure DemoInfo Class

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/configuration.md

Defines the metadata, behavior, and UI settings for a demo instance.

```csharp
public class DemoInfo
{
    // Display
    public string SampleName { get; set; }                  // ID
    public string Title { get; set; }                       // Display name
    public string Description { get; set; }                 // User description
    public string GroupName { get; set; }                   // Category grouping
    public string ControlName { get; set; }                 // Control name
    
    // Behavior
    public Type DemoViewType { get; set; }                  // View to instantiate
    public DemoLauchMode DemoLauchMode { get; set; }       // Launch in window or inline
    public ThemeMode ThemeMode { get; set; } = ThemeMode.Inherit;  // Theme handling
    
    // Status
    public Tag Tag { get; set; }                            // New/Updated/None
    public bool PreviewTag { get; set; }                    // Preview flag
    
    // UI
    public bool ShowBusyIndicator { get; set; } = true;     // Show loading indicator
    public bool IsShowcase { get; set; }                    // Showcase demo
    public bool IsAISample { get; set; }                    // AI-integrated
    
    // Documentation
    public List<Documentation> Documentations { get; set; } // Help links
    public List<DemoInfo> SubCategoryDemos { get; set; }   // Child demos
}
```

--------------------------------

### Apply Themes to DemoControl

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Demonstrates applying themes via the constructor or the SfSkinManager. Ensure the theme name matches available Syncfusion theme identifiers.

```csharp
// Apply theme via constructor
var demo = new DemoControl("Office2019Colorful");

// Or via SkinManager after creation
SfSkinManager.SetTheme(demo, Theme.GetTheme("Windows11Dark"));
```

--------------------------------

### Implement Custom Demo ViewModel

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/sample-browser-viewmodel.md

Extend DemoBrowserViewModel by overriding GetDemosDetails to provide specific product definitions.

```csharp
public class MyDemoViewModel : DemoBrowserViewModel
{
    public override List<ProductDemo> GetDemosDetails()
    {
        // Return product definitions
    }
}

// Usage
var viewModel = new MyDemoViewModel();
// All collections automatically populated via constructor
```

--------------------------------

### Organize Demo Hierarchy

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/product-demo-models.md

Demonstrates nesting child demos within a parent DemoInfo object.

```csharp
// Parent demo
var parentDemo = new DemoInfo
{
    SampleName = "AdvancedFeatures",
    Title = "Advanced Features",
    GroupName = "Advanced",
    SubCategoryDemos = new List<DemoInfo>
    {
        // Child demos
        new DemoInfo 
        { 
            SampleName = "Grouping",
            Title = "Grouping",
            GroupName = "Advanced"
        },
        new DemoInfo 
        { 
            SampleName = "Filtering",
            Title = "Filtering",
            GroupName = "Advanced"
        }
    }
};
```

--------------------------------

### NavigationViewModel()

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/navigation-view-model.md

Initializes a new instance of the NavigationViewModel class.

```APIDOC
## NavigationViewModel()

### Description
Initializes a new instance of the NavigationViewModel class. This is a default parameterless constructor.

### Signature
`public NavigationViewModel()`

### Usage Example
```csharp
var navItem = new NavigationViewModel();
navItem.NavigationItem = "Home";
navItem.NavigationIcon = iconSource;
```
```

--------------------------------

### Configure DemoControl with Documentation Links

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Bind documentation links to the DemoControl using the DocumentsItemSource property.

```xml
<local:DemoControl 
    Title="Scheduler Demo"
    ControlName="SfScheduler"
    DocumentsItemSource="{Binding DocumentationLinks}">
    
    <local:SchedulerSampleView />
</local:DemoControl>
```

--------------------------------

### Load Dock State from Binary

Source: https://github.com/syncfusion/wpf-demos/blob/master/dockingmanager/Assets/DockingManager/StatePersistence/StatePersistence_cs.txt

Loads the dock state from a binary file. Includes error handling for serialization and XML exceptions.

```csharp
BinaryFormatter formatter1 = new BinaryFormatter();
try
{
    dockingManager.LoadDockState(formatter1, StorageFormat.Binary, AppDomain.CurrentDomain.BaseDirectory.ToString() + "\\docking_bin.bin");
}
catch (SerializationException ex)
{
    MessageBox.Show(ex.Message, AttentionHeader, MessageBoxButton.OK, MessageBoxImage.Warning);
}
catch (XmlException ex)
{
    MessageBox.Show(ex.Message, AttentionHeader, MessageBoxButton.OK, MessageBoxImage.Warning);
}
```

--------------------------------

### Initialize Palette model

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/product-demo-models.md

Create a new instance of the Palette class to define theme colors and identifiers.

```csharp
var palette = new Palette
{
    Name = "Default",
    Theme = "Windows11Light",
    DisplayName = "Default Palette",
    PrimaryBackground = new SolidColorBrush(Colors.White),
    PrimaryForeground = new SolidColorBrush(Colors.Black),
    PrimaryBackgroundAlt = new SolidColorBrush(Color.FromRgb(240, 240, 240))
};
```

--------------------------------

### Define Product Metadata

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/README.md

Subclass ProductDemo to register your control and its associated demo samples.

```csharp
public class MyProductDemo : ProductDemo
{
    public MyProductDemo()
    {
        Product = "My Control";
        ProductCategory = "CATEGORY";
        ControlDescription = "Control description";
        Demos = new List<DemoInfo>
        {
            new DemoInfo
            {
                SampleName = "BasicSample",
                Title = "Basic Usage",
                Description = "Shows basic functionality",
                DemoViewType = typeof(BasicSampleView),
                ThemeMode = ThemeMode.Inherit,
                ShowBusyIndicator = true
            }
        };
    }
}
```

--------------------------------

### Project Directory Structure

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/README.md

Overview of the repository organization, separating reusable framework components from specific control demos.

```text
wpf-demos/
├── common/                          # Reusable framework
│   ├── MVVM/
│   │   ├── BaseCommand.cs
│   │   ├── DelegateCommand.cs
│   │   └── NotificationObject.cs
│   ├── Converter/                   # Value converters
│   ├── Model/
│   │   ├── ProductDemo.cs           # ProductDemo, DemoInfo, etc.
│   │   └── NavigationViewModel.cs
│   ├── Views/
│   │   ├── DemoView.cs              # DemoControl class
│   │   └── ...
│   ├── ViewModel/
│   │   └── SampleBrowserViewModel.cs # DemoBrowserViewModel
│   └── Behaviors/
│       └── LaunchDemoAction.cs      # Demo launching infrastructure
│
├── editor/                          # Specific control demo (example)
├── datagrid/
├── chart/
└── ... (40+ control demo folders)
```

--------------------------------

### Load Dock State from XML with SOAP formatter

Source: https://github.com/syncfusion/wpf-demos/blob/master/dockingmanager/Assets/DockingManager/StatePersistence/StatePersistence_cs.txt

Loads the dock state from an XML file using a SOAP formatter. Includes error handling for XML and invalid operation exceptions.

```csharp
SoapFormatter formatter1 = new SoapFormatter();

try
{
    dockingManager.LoadDockState(formatter1, StorageFormat.Xml, AppDomain.CurrentDomain.BaseDirectory.ToString() + "\\docking_xml_soap.xml");
}
catch (XmlException ex)
{
    MessageBox.Show(ex.Message, AttentionHeader, MessageBoxButton.OK, MessageBoxImage.Warning);
}
catch (InvalidOperationException ex)
{
    MessageBox.Show(ex.Message, AttentionHeader, MessageBoxButton.OK, MessageBoxImage.Warning);
}
```

--------------------------------

### Configure Options Panel

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Define the options panel content and layout settings.

```xml
<local:DemoControl OptionsPosition="Right" OptionsSize="250">
    <local:DemoControl.Options>
        <StackPanel>
            <CheckBox Content="Enable Sorting" />
            <ComboBox ItemsSource="{Binding Themes}" />
        </StackPanel>
    </local:DemoControl.Options>
    <!-- Main content here -->
</local:DemoControl>
```

--------------------------------

### Configure NavigationIcon Variants

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/navigation-view-model.md

Demonstrates setting the icon using path data or a BitmapImage.

```csharp
var navItem = new NavigationViewModel
{
    NavigationItem = "Home",
    NavigationIcon = "M0,0 L10,10 L0,20 Z" // Path data
};

var navItem2 = new NavigationViewModel
{
    NavigationItem = "Settings",
    NavigationIcon = new BitmapImage(new Uri("pack://..."))
};
```

--------------------------------

### Load Docking Manager State from XML

Source: https://github.com/syncfusion/wpf-demos/blob/master/dockingmanager/Assets/DockingManager/StatePersistence/StatePersistence_cs.txt

Loads the Docking Manager state from an XML file using BinaryFormatter. Ensure the file path and formatter are correct for successful loading.

```csharp
BinaryFormatter formatter1 = new BinaryFormatter();
```

--------------------------------

### Apply Themes via Framework Components

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/README.md

Methods for applying themes to demo controls and views using the framework's constructors or the SkinManager.

```csharp
new DemoControl("Windows11Light")
```

```csharp
new MyDemoView("Windows11Light")
```

```csharp
SfSkinManager.SetTheme(control, theme)
```

--------------------------------

### Define Navigation Collection

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/navigation-view-model.md

Shows how to initialize a list of NavigationViewModel objects for menu structures.

```csharp
var navigationItems = new List<NavigationViewModel>
{
    new NavigationViewModel 
    { 
        NavigationItem = "All Controls",
        NavigationIcon = allControlsIcon
    },
    new NavigationViewModel 
    { 
        NavigationItem = "What's New",
        NavigationIcon = whatsNewIcon
    },
    new NavigationViewModel 
    { 
        NavigationItem = "Showcase",
        NavigationIcon = showcaseIcon
    }
};
```

--------------------------------

### Load Layout 1 from XML

Source: https://github.com/syncfusion/wpf-demos/blob/master/dockingmanager/Assets/DockingManager/StatePersistence/StatePersistence_cs.txt

Loads a specific layout (Layout1) from an XML file using a Binary formatter.

```csharp
BinaryFormatter formatter1 = new BinaryFormatter();
this.StatePersistenceService.LoadDockState(formatter1, StorageFormat.Xml, @"Assets/DockingManager/StatePersistence/Layout1.xml");
```

--------------------------------

### Implement Lazy Command Creation in C#

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/README.md

Use this pattern to instantiate commands only when they are first accessed, reducing memory overhead.

```csharp
private DelegateCommand<string> searchCommand;

public ICommand SearchCommand
{
    get
    {
        return searchCommand ?? (searchCommand = 
            new DelegateCommand<string>(Search));
    }
}
```

--------------------------------

### Configure DemoControl Content Properties

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/configuration.md

Sets the primary content, options controls, documentation links, and metadata for the demo container.

```csharp
// Demo content
public object Content { get; set; }

// Options controls
public object Options { get; set; }

// Documentation
public object DocumentsItemSource { get; set; }
public Style HyperLinkStyle { get; set; }

// Metadata (read-only in XAML designer)
public string Title { get; set; }
public string ControlName { get; set; }
public string Description { get; set; }
```

--------------------------------

### Load Layout 2 from XML

Source: https://github.com/syncfusion/wpf-demos/blob/master/dockingmanager/Assets/DockingManager/StatePersistence/StatePersistence_cs.txt

Loads a specific layout (Layout2) from an XML file using a Binary formatter.

```csharp
BinaryFormatter formatter1 = new BinaryFormatter();
this.StatePersistenceService.LoadDockState(formatter1, StorageFormat.Xml, @"Assets/DockingManager/StatePersistence/Layout2.xml");
```

--------------------------------

### Configure DemoControl Options Panel

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/configuration.md

Define the layout, options panel content, and documentation links for a demo using the DemoControl XAML element.

```xml
<local:DemoControl 
    Title="Data Grid Demo"
    ControlName="SfDataGrid"
    Description="Demonstrates selection and sorting features"
    OptionsPosition="Right"
    OptionsSize="280"
    OptionsTitle="Configuration"
    OptionsVerticalScrollBarVisibility="Auto">
    
    <!-- Main content -->
    <local:DataGridDemoView />
    
    <!-- Options panel -->
    <local:DemoControl.Options>
        <StackPanel Margin="10">
            <TextBlock Text="Selection Mode:" FontWeight="Bold" />
            <ComboBox ItemsSource="{Binding SelectionModes}"
                      SelectedItem="{Binding SelectedMode}" />
            
            <Separator Margin="0,10" />
            
            <CheckBox Content="Enable Sorting"
                      IsChecked="{Binding IsSortingEnabled}" />
            <CheckBox Content="Enable Filtering"
                      IsChecked="{Binding IsFilteringEnabled}" />
        </StackPanel>
    </local:DemoControl.Options>
    
    <!-- Documentation -->
    <local:DemoControl.DocumentsItemSource>
        <system:Collections.ObjectModel.ObservableCollection x:TypeArguments="local:Documentation">
            <local:Documentation Content="Getting Started"
                                Uri="https://help.syncfusion.com/..." />
            <local:Documentation Content="API Reference"
                                Uri="https://help.syncfusion.com/..." />
        </system:Collections.ObjectModel.ObservableCollection>
    </local:DemoControl.DocumentsItemSource>
</local:DemoControl>
```

--------------------------------

### Configure DemoControl Metadata

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Set display properties for the demo title, control name, and description.

```csharp
demoControl.Title = "Default Functionality";
```

```csharp
demoControl.ControlName = "DataGrid";
```

```csharp
demoControl.Description = "This demo shows how to configure column selection modes.";
```

--------------------------------

### Load Layout 3 from XML

Source: https://github.com/syncfusion/wpf-demos/blob/master/dockingmanager/Assets/DockingManager/StatePersistence/StatePersistence_cs.txt

Loads a specific layout (Layout3) from an XML file using a Binary formatter.

```csharp
BinaryFormatter formatter1 = new BinaryFormatter();
this.StatePersistenceService.LoadDockState(formatter1, StorageFormat.Xml, @"Assets/DockingManager/StatePersistence/Layout3.xml");
```

--------------------------------

### Load Dock State from XML

Source: https://github.com/syncfusion/wpf-demos/blob/master/dockingmanager/Assets/DockingManager/StatePersistence/StatePersistence_cs.txt

Loads the dock state from an XML file. Includes error handling for XML and invalid operation exceptions.

```csharp
try
{
    dockingManager.LoadDockState(formatter1, StorageFormat.Xml, AppDomain.CurrentDomain.BaseDirectory.ToString() + "\\docking_xml.xml");
}
catch (XmlException ex)
{
    MessageBox.Show(ex.Message, AttentionHeader, MessageBoxButton.OK, MessageBoxImage.Warning);
}
catch (InvalidOperationException ex)
{
    MessageBox.Show(ex.Message, AttentionHeader, MessageBoxButton.OK, MessageBoxImage.Warning);
}
```

--------------------------------

### Configure Options Panel Size

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Set the width or height of the options panel based on its position.

```xml
<!-- Options panel 300 pixels wide on the right -->
<local:DemoControl OptionsPosition="Right" OptionsSize="300">
    ...
</local:DemoControl>

<!-- Options panel 150 pixels tall at the top -->
<local:DemoControl OptionsPosition="Top" OptionsSize="150">
    ...
</local:DemoControl>
```

--------------------------------

### Save Docking Manager State to Binary with SOAP

Source: https://github.com/syncfusion/wpf-demos/blob/master/dockingmanager/Assets/DockingManager/StatePersistence/StatePersistence_cs.txt

Saves the Docking Manager state to a binary file using SoapFormatter. This option is suitable for cross-platform compatibility and is not available for NET50.

```csharp
#if !NET50
                    SoapFormatter formatter1 = new SoapFormatter();
                    dockingManager.SaveDockState(formatter1, StorageFormat.Binary, AppDomain.CurrentDomain.BaseDirectory.ToString() + "\\docking_bin_soap.bin");
#endif
```

--------------------------------

### Implement Navigation Drawer ViewModel

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/navigation-view-model.md

Shows the integration of NavigationViewModel within a parent ViewModel for navigation drawers.

```csharp
public class SampleBrowserViewModel : DemoBrowserViewModel
{
    public ObservableCollection<NavigationViewModel> HeaderItems { get; set; }

    public SampleBrowserViewModel()
    {
        HeaderItems = new ObservableCollection<NavigationViewModel>
        {
            new NavigationViewModel 
            { 
                NavigationItem = "All Controls",
                NavigationIcon = CreatePathGeometry("M0,0 L10,10...")
            },
            new NavigationViewModel 
            { 
                NavigationItem = "Whats New",
                NavigationIcon = CreatePathGeometry("M0,5 L5,0...")
            },
            new NavigationViewModel 
            { 
                NavigationItem = "Showcase",
                NavigationIcon = CreatePathGeometry("M0,0 L10,0...")
            }
        };
    }

    private object CreatePathGeometry(string pathData)
    {
        return pathData; // Or create actual Geometry object
    }
}
```

--------------------------------

### Define Themes Class

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/product-demo-models.md

Basic class definition for theme configuration.

```csharp
public class Themes
```

--------------------------------

### Assigning a Tag to DemoInfo

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/types.md

Demonstrates how to assign a Tag to a DemoInfo object to trigger UI badge display.

```csharp
var demo = new DemoInfo
{
    SampleName = "NewFeatureSample",
    Title = "New Feature Demo",
    Tag = Tag.New  // Display "NEW" badge
};
```

--------------------------------

### BaseCommand Constructor

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/mvvm-commands.md

Initializes a new instance of the BaseCommand class with execution and optional can-execute logic.

```APIDOC
## BaseCommand Constructor

### Signature
`public BaseCommand(Action<object> execute)`
`public BaseCommand(Action<object> execute, Predicate<object> canExecute)`

### Parameters
- **execute** (Action<object>) - Required - The execution logic to perform when the command is invoked.
- **canExecute** (Predicate<object>) - Optional - The condition logic to determine if the command can execute. Defaults to null (always executable).
```

--------------------------------

### Configure IsIOSDKSample

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/configuration.md

Indicates whether this is an Excel SDK or IO library demo browser, affecting busy indicator timing.

```csharp
public static bool IsIOSDKSample { get; set; } = false
```

--------------------------------

### Configure Store Application Mode

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/README.md

Set the static flag to disable file system access and restricted APIs for Store environment compatibility.

```csharp
DemoBrowserViewModel.IsStoreApp = true;
```

--------------------------------

### Access AppCulture

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/configuration.md

Retrieves or sets the UI culture determined at application startup.

```csharp
public static System.Globalization.CultureInfo AppCulture
```

```csharp
// Check culture in ViewModel initialization
if (DemoBrowserViewModel.AppCulture.TwoLetterISOLanguageName == "en")
{
    // English-specific initialization
}
```

--------------------------------

### Configure DefaultThemeName

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/configuration.md

Defines the theme applied when DemoInfo.ThemeMode is set to Default. Set this property before initializing the SampleBrowserViewModel.

```csharp
public static string DefaultThemeName = "Windows11Light"
```

```csharp
// Set global default theme before creating ViewModel
DemoBrowserViewModel.DefaultThemeName = "Office2019Colorful";

var viewModel = new SampleBrowserViewModel();
```

--------------------------------

### Implement MVVM Commands

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/README.md

Implementation of an ICommand property using DelegateCommand and its corresponding XAML binding.

```csharp
private ICommand updateCommand;

public ICommand UpdateCommand
{
    get
    {
        if (updateCommand == null)
        {
            updateCommand = new DelegateCommand<object>(
                executeAction: (param) => OnUpdate(),
                canExecute: (param) => CanUpdate()
            );
        }
        return updateCommand;
    }
}
```

```xml
<Button Command="{Binding UpdateCommand}" Content="Update" />
```

--------------------------------

### LaunchDemoAction XAML Usage

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-launcher.md

Demonstrates how to attach the LaunchDemoAction to a Button using Interaction Triggers.

```xml
<Button Content="Launch Demo">
    <i:Interaction.Triggers>
        <i:EventTrigger EventName="Click">
            <local:LaunchDemoAction />
        </i:EventTrigger>
    </i:Interaction.Triggers>
</Button>
```

--------------------------------

### Configure IsDocumentSDKSample

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/configuration.md

Indicates whether this is a Document format library demo browser.

```csharp
public static bool IsDocumentSDKSample { get; set; } = false
```

--------------------------------

### Define ProductDemo Class

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/product-demo-models.md

Represents the abstract base class for defining a Syncfusion control product.

```csharp
public abstract class ProductDemo
```

--------------------------------

### Save Docking Manager State to Binary

Source: https://github.com/syncfusion/wpf-demos/blob/master/dockingmanager/Assets/DockingManager/StatePersistence/StatePersistence_cs.txt

Saves the Docking Manager state to a binary file using BinaryFormatter. This method is efficient for storing complex object states.

```csharp
BinaryFormatter formatter1 = new BinaryFormatter();
dockingManager.SaveDockState(formatter1, StorageFormat.Binary, AppDomain.CurrentDomain.BaseDirectory.ToString() + "\\docking_bin.bin");
```

--------------------------------

### Implement NavigationViewModel in DemoBrowserViewModel

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/navigation-view-model.md

Demonstrates managing a collection of NavigationViewModel instances within a ViewModel, typically used for header navigation or category grouping.

```csharp
public abstract class DemoBrowserViewModel : NotificationObject
{
    private ObservableCollection<NavigationViewModel> headerItems;

    public ObservableCollection<NavigationViewModel> HeaderItems
    {
        get { return headerItems; }
        set
        {
            headerItems = value;
            RaisePropertyChanged(nameof(HeaderItems));
        }
    }

    protected void NavigationItems()
    {
        HeaderItems = new ObservableCollection<NavigationViewModel>
        {
            new NavigationViewModel 
            { 
                NavigationItem = "All Controls",
                NavigationIcon = GetAllControlsIcon()
            },
            new NavigationViewModel 
            { 
                NavigationItem = "What's New",
                NavigationIcon = GetWhatsNewIcon()
            },
            // ... more items
        };
    }
}
```

--------------------------------

### Programmatic DemoControl Configuration

Source: https://github.com/syncfusion/wpf-demos/blob/master/_autodocs/api-reference/demo-control.md

Configure the DemoControl instance within a ViewModel using C# code.

```csharp
public class MyDemoViewModel : NotificationObject
{
    private DemoControl demoControl;

    public void ConfigureDemo()
    {
        demoControl = new DemoControl("Windows11Light")
        {
            Title = "Advanced DataGrid",
            ControlName = "SfDataGrid",
            Description = "Shows grouping, filtering, and sorting.",
            OptionsPosition = Dock.Right,
            OptionsSize = new GridLength(280),
            OptionsTitle = "Options",
            OptionsVerticalScrollBarVisibility = ScrollBarVisibility.Auto,
            Content = new DataGridView(),
            Options = CreateOptionsPanel(),
            DocumentsItemSource = new List<Documentation>
            {
                new Documentation
                {
                    Content = "API Reference",
                    Uri = new Uri("https://help.syncfusion.com/...")
                }
            }
        };
    }

    private StackPanel CreateOptionsPanel()
    {
        var panel = new StackPanel { Margin = new Thickness(10) };
        panel.Children.Add(new TextBlock { Text = "Sorting" });
        panel.Children.Add(new CheckBox { Content = "Enable" });
        return panel;
    }
}
```

--------------------------------

### Save Docking Manager State to XML with SOAP

Source: https://github.com/syncfusion/wpf-demos/blob/master/dockingmanager/Assets/DockingManager/StatePersistence/StatePersistence_cs.txt

Saves the Docking Manager state to an XML file using SoapFormatter. This is available for non-NET50 projects.

```csharp
#if !NET50
                    SoapFormatter formatter1 = new SoapFormatter();
                    dockingManager.SaveDockState(formatter1, StorageFormat.Xml, AppDomain.CurrentDomain.BaseDirectory.ToString() + "\\docking_xml_soap.xml");
#endif
```
Tokens:
Raw