Content builders control what appears inside tiles across all tile-based pages in Security Desk. This includes the monitoring task, alarm monitoring, and activity/report tasks such as door activity and cardholder activity. Any page that displays tiles uses content builders to produce the visual content for those tiles.

When an entity is dragged onto a tile, an event fires, or an alarm triggers, the system asks registered content builders to produce the content for the tile.

The system iterates through all registered ContentBuilder components sorted by Priority (lowest value first). The first builder that returns a non-null result provides the content for the tile. Builders that return null pass control to the next builder in the chain.

Content builders serve three purposes:

• Routing: Claim specific entity types and control how they display in tiles
• Configuration: Set properties on content objects like video mode, playback time, title, and icon
• Composition: Inject sub-content into tiles built by other content builders

When something needs to display in a tile, the system follows this sequence:

1. The input (entity GUID, event data, alarm data, report row) is converted to a FieldsCollection, a dictionary of field name/value pairs
2. The system creates a ContentBuilderContext containing the fields and metadata
3. Registered ContentBuilder components are evaluated in priority order via BuildContentGroup until one returns a non-null result
4. The first builder that returns a non-null ContentGroup provides the primary tile content
5. The builder that returned the primary ContentGroup may request sub-content for related entities
6. When sub-content is requested, registered ContentBuilder components are evaluated in priority order via BuildContent
7. Returned sub-content is merged into the primary content group
8. The tile rendering system displays the assembled content

Content builders have two build methods, called at different stages:

BuildContentGroup starts primary content selection. The system iterates builders sorted by priority and calls BuildContentGroup until one returns a non-null result.

BuildContent is called second, but not automatically. The builder that returned the primary ContentGroup decides whether to request sub-content for related entities. For example, the built-in door content flow detects a cardholder in the event data, requests sub-content for that cardholder, and evaluates registered content builders through BuildContent.

This is a pull-based, synchronous workflow. The complete sequence happens within a single call chain:

BuildContentGroup called on builders (priority order) until one returns non-null
  └─ Builder returns primary ContentGroup
     └─ Builder may request sub-content for relatedEntityGuid
        └─ BuildContent called on each builder (priority order)
           └─ Returned Content merged into primary ContentGroup

A content builder can implement both methods. BuildContentGroup handles primary content, BuildContent handles sub-content injection. Most custom builders implement only one of the two.

Built-in content flows request sub-content for related entities during tile assembly. The following scenarios trigger BuildContent on registered builders:

If your builder implements BuildContent, it is called during any of these scenarios when the source entity matches what your builder handles.

When BuildContent is called, the context contains:

• SourceId: The GUID of the related entity (e.g., the cardholder, camera, or access point)
• Parent: The primary ContentGroup being assembled
• Fields: The FieldsCollection from the primary content build. The fields belong to the parent content group, not to the SourceId entity. This means BuildContent receives the original event, alarm, or entity fields, not fields specific to the sub-entity being built.

This allows sub-content builders to read event data (timestamps, event types) while also knowing which specific entity the sub-content is being built for.

BuildContent can modify context.Parent directly instead of returning a new Content. The Parent is a reference to the content group being assembled, so changes to its properties (such as Title, Icon, or Contents) take effect immediately.

public override Content BuildContent(ContentBuilderContext context)
{
    if (context.Parent is EntityContentGroup entityGroup)
    {
        entityGroup.Title = $"{entityGroup.Title} (Modified)";
    }

    return null;
}

When modifying the parent, return null to indicate that no new sub-content is being added. The system collects returned Content objects and merges them into the parent separately, so modifications to the parent and returning a new Content are independent operations.

When BuildContent is called, Parent.Contents does not yet contain sub-content from other builders. The system collects all returned Content objects into a list first, then merges them into the parent after all builders have been called. The parent only contains whatever the primary BuildContentGroup builder put into it initially.

Parent is null in BuildContentGroup. In BuildContent, Parent is provided when available, but it can be null when sub-content is built without a parent. Its runtime type depends on what the primary BuildContentGroup builder returned for the tile. Cast Parent to access properties specific to the content scenario:

public override Content BuildContent(ContentBuilderContext context)
{
    if (context.Parent is EventContent eventContent)
    {
        var eventTime = eventContent.Time;
        var eventType = eventContent.Type;
    }
    else if (context.Parent is AlarmContent alarmContent)
    {
        var alarmPriority = alarmContent.Priority;
        var triggerTime = alarmContent.TriggerTime;
    }

    return null;
}

The ContentBuilderContext object provides the data needed to build content.

The fields available in context.Fields depend on what triggered the content build. The system converts different input types to a FieldsCollection before calling content builders. There is no universal "Id" field across all input types.

When an entity is dragged onto a tile, the system creates a FieldsCollection with a single field:

Read the entity GUID:

var entityId = context.Fields.GetValueOrDefault<Guid>("Id");

When an event triggers content building, the FieldsCollection contains fields populated from the event data. Events typically include EventType and EventSubType. Other fields such as EventTimestamp, SourceEntityGuid, Latitude, and Longitude may be present depending on the event source and payload:

Module-specific event extenders add additional fields depending on the event type. For access control events:

For custom events, event extenders can add any custom fields. See the event extender use case in this document for an example.

Read event fields:

var sourceEntity = context.Fields.GetValueOrDefault<Guid>("SourceEntityGuid");
var eventType = context.Fields.GetValueOrDefault<EventType>("EventType");
var eventTime = context.Fields.GetValueOrDefault<DateTime>("EventTimestamp");
var cameraGuid = context.Fields.GetValueOrDefault<Guid>("CameraGuid");

When an alarm triggers content building, the FieldsCollection contains alarm-specific fields:

Read alarm fields:

var alarmGuid = context.Fields.GetValueOrDefault<Guid>("AlarmGuid");
var sourceGuid = context.Fields.GetValueOrDefault<Guid>("AlarmSourceGuid");
var triggerTime = context.Fields.GetValueOrDefault<DateTime>("AlarmTriggerTime");
var priority = context.Fields.GetValueOrDefault<int>("AlarmPriority");

When a report row (activity task) triggers content building, the FieldsCollection is populated from the DataRow columns. The available fields depend on the specific report, but typically include the same field names as events (e.g., "SourceEntityGuid", "EventType", "EventTimestamp", "CameraGuid").

To determine what type of input your builder is handling, check which fields are present:

public override ContentGroup BuildContentGroup(ContentBuilderContext context)
{
    if (context.Fields.Contains("AlarmGuid"))
    {
        // Alarm input
    }
    else if (context.Fields.Contains("EventType"))
    {
        // Event or report row input
    }
    else if (context.Fields.Contains("Id"))
    {
        // Entity drag-and-drop input
    }

    return null;
}

The Genetec.Sdk.Reports.Fields.DefaultFields class provides constants for common field names:

Using constants instead of string literals ensures forward compatibility:

using Genetec.Sdk.Reports.Fields;

var sourceEntity = context.Fields.GetValueOrDefault<Guid>(DefaultFields.SourceId);
var cameraGuid = context.Fields.GetValueOrDefault<Guid>(DefaultFields.CameraId);

Custom entities already display in tiles by default. The system shows the entity icon, name, and video from any assigned cameras. A content builder lets you customize this display.

In this example, the builder intercepts an AED unit custom entity type and sets a descriptive title showing the device status, instead of just the entity name.

public class AedUnitContentBuilder : ContentBuilder
{
    public override string Name => "AED Unit ContentBuilder";

    public override Guid UniqueId { get; } = new("B1A2C3D4-E5F6-7890-ABCD-EF1234567890");

    public override int Priority => 150;

    public override ContentGroup BuildContentGroup(ContentBuilderContext context)
    {
        var entityId = context.Fields.GetValueOrDefault<Guid>("Id");
        if (entityId == Guid.Empty)
            return null;

        var entity = Workspace.Sdk.GetEntity(entityId) as CustomEntity;
        if (entity == null || entity.CustomEntityType != AedUnitCustomEntityType.Id)
            return null;

        var contentGroup = new EntityContentGroup(entityId);
        contentGroup.Initialize(Workspace);
        contentGroup.Title = entity.RunningState == State.Running
            ? $"{entity.Name} (Online)"
            : $"{entity.Name} (Offline)";

        return contentGroup;
    }
}

When a custom entity is dragged to a tile with no custom content builder registered, the system:

• Creates a default content group for the entity
• Displays the entity icon and name
• If the entity has camera children, displays their video feeds as sub-content

The content builder intercepts the entity before the default handler and returns an EntityContentGroup with a customized title. The cameras still display as sub-content because EntityContentGroup is a built-in type the system already knows how to render. The builder only needs to customize what it cares about (the title) and the rest works automatically.

When a custom event fires on a camera, a content builder can configure how the video tile displays the event. For example, it can set the video to play back at a specific timestamp instead of showing a live feed.

This use case combines three components: a custom event with a JSON payload, an event extender that deserializes the payload into fields, and a content builder that reads those fields to configure the video content.

On the Platform SDK side, the analytics system raises a CustomEventInstance on a camera with a JSON payload in ExtraHiddenPayload.

var eventInstance = (CustomEventInstance)engine.ActionManager.BuildEvent(
    EventType.CustomEvent, cameraGuid);
eventInstance.Id = new CustomEventId(analyticsEventId);
eventInstance.ExtraHiddenPayload = new AnalyticsPayload
{
    DetectionTimestamp = DateTime.UtcNow.AddSeconds(-3),
    Label = "Person detected in restricted zone"
}.Serialize();
engine.ActionManager.RaiseEvent(eventInstance);

An EventExtender deserializes the JSON payload and populates the FieldsCollection with typed fields.

public class AnalyticsEventExtender : EventExtender
{
    public override IList<Field> Fields { get; } =
    [
        new("DetectionTimestamp", typeof(DateTime)) { Title = "Detection Time", IsDisplayable = true },
        new("DetectionLabel", typeof(string)) { Title = "Label", IsDisplayable = true }
    ];

    public override bool Extend(Event @event, FieldsCollection fields)
    {
        if (@event is CustomEventInstance instance
            && AnalyticsPayload.TryDeserialize(instance.ExtraHiddenPayload, out var payload))
        {
            fields["DetectionTimestamp"] = payload.DetectionTimestamp;
            fields["DetectionLabel"] = payload.Label;
            return true;
        }
        return false;
    }
}

The content builder reads the detection timestamp from the fields and returns a VideoContent configured for playback at that time.

public override Content BuildContent(ContentBuilderContext context)
{
    var timestamp = context.Fields.GetValueOrDefault<DateTime>("DetectionTimestamp");
    if (timestamp == default)
        return null;

    var cameraGuid = context.Fields.GetValueOrDefault<Guid>("CameraGuid");
    if (cameraGuid == Guid.Empty)
        return null;

    var content = new VideoContent(cameraGuid);
    content.Initialize(Workspace);
    content.VideoMode = VideoMode.Playback;
    content.SetPlaybackTimestamp(timestamp);
    content.SetLooping(timestamp.AddSeconds(-5), timestamp.AddSeconds(10));
    return content;
}

Without this content builder, the event tile shows a live video feed. With it, the tile automatically plays a 15-second video loop centered on the detection moment, so the operator sees exactly what triggered the alert.

Content builders can configure the following properties on VideoContent:

When a visitor badges at a door, the built-in door content builder creates a tile showing the cardholder photo, name, and camera feeds. A content builder can inject additional content into this tile, such as visitor details read from custom fields.

During tile assembly, the door content flow requests sub-content for the cardholder involved in the access event. Registered content builders are then evaluated through BuildContent(), with context.SourceId set to the cardholder GUID.

public class VisitorContentBuilder : ContentBuilder
{
    public override string Name => "Visitor ContentBuilder";

    public override Guid UniqueId { get; } = new("A1B2C3D4-E5F6-7890-ABCD-EF1234567890");

    private CustomField m_companyField;

    protected override void Initialize()
    {
        var config = (SystemConfiguration)Workspace.Sdk.GetEntity(
            SystemConfiguration.SystemConfigurationGuid);
        var customFieldService = config.CustomFieldService;

        m_companyField = customFieldService.CustomFields
            .FirstOrDefault(cf => cf.Name == "Company"
                               && cf.EntityType == EntityType.Visitor);
    }

    public override Content BuildContent(ContentBuilderContext context)
    {
        if (context.SourceId == Guid.Empty || m_companyField == null)
            return null;

        var visitor = Workspace.Sdk.GetEntity(context.SourceId) as Visitor;
        if (visitor == null)
            return null;

        var config = (SystemConfiguration)Workspace.Sdk.GetEntity(
            SystemConfiguration.SystemConfigurationGuid);
        var company = config.CustomFieldService.GetValue(
            m_companyField, visitor.Guid) as string;
        if (string.IsNullOrEmpty(company))
            return null;

        var escort = Workspace.Sdk.GetEntity(visitor.Escort) as Cardholder;

        var content = new EntityContent();
        content.Initialize(Workspace);
        content.Title = $"Visitor: {company} (Host: {escort?.Name ?? "N/A"})";
        return content;
    }
}

The door event tile now shows an additional tab titled "Visitor: Acme Corp (Host: Jane Smith)" alongside the camera feeds and cardholder photo. For regular cardholders, the builder returns null and adds nothing.

When BuildContent is called as part of sub-content assembly, the context provides additional information:

Content builders return objects from two parallel hierarchies: Content and ContentGroup.

A ContentGroup is a container that holds one or more Content objects. Each tile in Security Desk displays exactly one ContentGroup. The Contents property is an ObservableCollection<Content> that holds all the content items in the group. A tile shows one content item at a time: the Current property points to the active item. When the operator cycles between items (for example, switching between a video feed and a map in the same tile), Current changes and the CurrentChanged event fires. Each Content item has a DwellTime property that controls how long it stays visible before the tile automatically advances to the next item in the group.

A Content object represents a single displayable item, such as a video feed, a map, or a web page.

An EntityContentGroup is a ContentGroup that associates the group with a specific entity through its EntityId property. Use EntityContentGroup when the tile represents a known entity. The system has built-in tile views that handle EntityContentGroup, so no custom TileViewBuilder is needed. Use the base ContentGroup when the content is not associated with a single entity or when you build the group manually from unrelated content items.

classDiagram
    class Content {
        <<abstract>>
        +Title : string
        +Icon : ImageSource
        +DwellTime : TimeSpan
        +Initialize(Workspace)
    }

    class EntityContent {
        +EntityId : Guid
    }

    class VideoContent {
        +VideoContent(Guid cameraId)
        +VideoMode : VideoMode
        +Play()
        +Pause()
        +Seek(DateTime)
        +SetPlaybackTimestamp(DateTime)
        +SetLooping(DateTime, DateTime)
    }

    class VideoFileContent {
        +VideoFileContent(string filePath)
        +FilePath : string
        +StartTime : DateTime
        +EndTime : DateTime
    }

    class MapContent {
        +MapContent(Guid map)
        +Center : GeoCoordinate
        +ZoomLevel : double
    }

    class TilePluginContent {
        +TilePluginContent(Guid tilePlugin)
        +Context : string
        +ContextId : Guid
    }

    class WebContent {
        +WebContent(Uri url)
        +Url : string
    }

    class ContentGroup {
        +Title : string
        +Icon : ImageSource
        +Contents : ObservableCollection~Content~
        +Current : Content
        +CurrentChanged : event
        +Initialize(Workspace)
    }

    class EntityContentGroup {
        +EntityContentGroup(Guid entityId)
        +EntityId : Guid
    }

    class SourceContent {
        <<abstract>>
        +SourceId : Guid
    }

    class EventContent {
        +Time : DateTime
        +Type : EventType
    }

    class CustomEventContent {
        +CustomEventId : int
    }

    class AlarmContent {
        <<sealed>>
        +EntityId : Guid
        +InstanceId : int
        +Priority : int
        +TriggerTime : DateTime
        +Location : GeoCoordinate
    }

    Content <|-- EntityContent
    EntityContent <|-- VideoContent
    VideoContent <|-- VideoFileContent
    EntityContent <|-- MapContent
    EntityContent <|-- TilePluginContent
    Content <|-- WebContent

    ContentGroup <|-- EntityContentGroup
    ContentGroup <|-- SourceContent
    SourceContent <|-- EventContent
    EventContent <|-- CustomEventContent
    SourceContent <|-- AlarmContent

These classes have public constructors. Content builders create and return instances of these types.

All built-in content types listed above have corresponding tile views registered by the system. Returning any of these types from a content builder works without additional setup. Creating a custom Content subclass requires a matching TileViewBuilder component to be registered, otherwise the system does not know how to render it. For most use cases, returning EntityContentGroup, VideoContent, or one of the other built-in types is sufficient.

var contentGroup = new EntityContentGroup(entityId);
contentGroup.Initialize(Workspace);

These classes have internal constructors. Content builders do not create them directly but encounter them as context.Parent when BuildContent is called.

All Content subclasses share these base properties:

All ContentGroup subclasses share these base members:

Content builders can add Content items to a ContentGroup.Contents collection before returning it from BuildContentGroup. The collection is synchronized with the tile rendering system, so items added at any point are displayed. For example, a builder could create an EntityContentGroup, add a VideoContent and a MapContent to its Contents, and return the group. The tile displays the first content item and the operator can cycle to the next.

Use ContentGroup.Clone() to create a deep copy of an existing content group, including all its contents:

ContentGroup cloned = originalContentGroup.Clone();

The cloned group contains independent copies of each Content item. Modifying the cloned group or its contents does not affect the original.

Content builders are called in order of their Priority property. Lower values run first.

public override int Priority => 150;

The default priority is int.MaxValue, which places unspecified builders at the end of the chain.

The system registers built-in content builders at the following priority ranges:

For most custom entity use cases, a priority between 101 and 249 is appropriate. This ensures your builder runs after all built-in entity-specific handlers (which top out at 100) but before the default custom entity handler (at 250) can claim the input.

Build methods execute on the UI thread. Do not perform blocking operations such as network calls or file I/O inside BuildContentGroup or BuildContent. Long-running operations block the UI and degrade the operator experience.

Register your content builder in the module's Load method and unregister it in Unload. Content builders are only available in Security Desk. Config Tool does not load content builders because it has no tile-based monitoring pages. Guard your registration with an ApplicationType check:

public class SampleModule : Module
{
    private AedUnitContentBuilder m_contentBuilder;

    public override void Load()
    {
        if (Workspace.ApplicationType == ApplicationType.SecurityDesk)
        {
            m_contentBuilder = new AedUnitContentBuilder();
            m_contentBuilder.Initialize(Workspace);
            Workspace.Components.Register(m_contentBuilder);
        }
    }

    public override void Unload()
    {
        if (m_contentBuilder != null)
        {
            Workspace.Components.Unregister(m_contentBuilder);
            m_contentBuilder = null;
        }
    }
}

The IContentBuilderService allows code outside of a content builder to trigger the content building pipeline programmatically. Retrieve the service from the workspace:

var service = Workspace.Services.Get<IContentBuilderService>();

Call Build with an entity GUID to produce a ContentGroup as if the entity had been dragged onto a tile:

ContentGroup contentGroup = service.Build(cameraGuid);

The service iterates through all registered content builders in priority order and returns the first non-null result. If no builder handles the input, it returns null.

For example, a custom map object view can call Build when the operator selects an entity on the map, then display the resulting content in a tile.

The input parameter accepts the following types. The service converts each type to a FieldsCollection before passing it to registered content builders.

// Entity GUID (most common)
ContentGroup content = service.Build(cameraGuid);

// Entity object
Camera camera = Workspace.Sdk.GetEntity(cameraGuid) as Camera;
ContentGroup content = service.Build(camera);

// Pre-built FieldsCollection
var fields = new FieldsCollection();
fields.Add("Id", cameraGuid);
ContentGroup content = service.Build(fields);

// Serialized XML
string xml = existingContentGroup.Serialize(Workspace);
ContentGroup content = service.Build(xml);

The ContentTypes parameter in Build(object input, ContentTypes contentTypes) restricts which built-in builders participate. Built-in builders declare which content types they handle (entity, event, alarm). The filter skips built-in builders that do not match.

SDK-registered content builders always participate regardless of this filter, because the SDK adapter opts into all content types.

A content builder can call IContentBuilderService.Build to let the system produce the default content for an entity, then customize the result. This is useful when you want the full content that the system would normally create (including sub-content such as PTZ controls, audio channels, and customizations from other builders) and then modify the title, add extra Content items, or change properties before returning it.

Without this technique, you would need to manually create and assemble every Content object yourself. Calling Build delegates that work to the standard pipeline and gives you a fully assembled ContentGroup to work with.

Use a re-entry guard to prevent infinite recursion. When the service iterates back to your builder during the nested Build call, the guard returns null, so the service skips your builder and continues to the next one. The default custom entity handler at priority 250 then produces the standard content, which is returned to your builder for customization.

Your builder must have a priority lower than 250 so that it intercepts the entity before the default handler. If the priority is 251 or higher, the default handler claims the entity first and your builder is never called.

public override int Priority => 150;

private bool m_building;

public override ContentGroup BuildContentGroup(ContentBuilderContext context)
{
    if (m_building)
        return null;

    var entityId = context.Fields.GetValueOrDefault<Guid>("Id");
    var entity = Workspace.Sdk.GetEntity(entityId) as CustomEntity;
    if (entity == null || entity.CustomEntityType != MyCheckpointType.Id)
        return null;

    m_building = true;
    try
    {
        // Let the system build the default content
        // for this entity. The guard causes this builder
        // to return null during the nested call, so the
        // default handler at priority 250 produces content.
        var service = Workspace.Services.Get<IContentBuilderService>();
        ContentGroup content = service.Build(entityId);
        if (content != null)
        {
            content.Title = $"{entity.Name} - Security Checkpoint";
        }
        return content;
    }
    finally
    {
        m_building = false;
    }
}

The build chain is synchronous and runs on the UI thread, so a simple boolean field is sufficient as a re-entry guard.

Content and ContentGroup both provide Serialize and Deserialize methods that convert to and from XML strings.

Serialize a ContentGroup to XML:

string xml = contentGroup.Serialize(Workspace);

Deserialize XML back to a ContentGroup:

ContentGroup contentGroup = ContentGroup.Deserialize(Workspace, xml);

Content has the same methods:

string xml = content.Serialize(Workspace);
Content content = Content.Deserialize(Workspace, xml);

Both methods return null if the serialization service is not available or if the XML is invalid.

The ActionManager.DisplayInTile method sends serialized content to a specific monitor and tile in Security Desk. This is a Platform SDK method available through Workspace.Sdk.ActionManager. Combined with IContentBuilderService and ContentGroup.Serialize, it enables a complete workflow: build content from an entity, serialize it, and push it to a tile on any monitor.

// Build content from an entity using registered content builders
var service = Workspace.Services.Get<IContentBuilderService>();
ContentGroup contentGroup = service.Build(cameraGuid);

// Serialize and display on monitor 1, tile 1
string xml = contentGroup.Serialize(Workspace);
Workspace.Sdk.ActionManager.DisplayInTile(MONITOR_ID, TILE_ID, xml);

The monitorId parameter is the logical ID of a Monitor entity in Security Center. Retrieve it from the Workspace SDK:

int monitorId = Workspace.Monitors[0].LogicalId;

The tileId parameter is the 1-based index of the tile in the tile layout. When the overload without tileId is used, or when tileId is -1, the content displays in the first empty tile.

// Get the monitor logical ID and tile index
var monitor = Workspace.Monitors[0];
int monitorId = monitor.LogicalId;

var tilePage = monitor.ActivePage as TilePage;
int tileCount = tilePage?.States.Count ?? 0;

Use GetTile to retrieve the XML content of a specific tile, and ClearTile to remove content from a tile:

// Get the content of tile 1 on monitor 1
string tileXml = Workspace.Sdk.ActionManager.GetTile(MONITOR_ID, 1);

// Clear the content of tile 1
Workspace.Sdk.ActionManager.ClearTile(MONITOR_ID, 1);

The XML format represents a TileContentGroup with nested content elements. To display a live camera feed without using IContentBuilderService:

string xml = $@"<TileContentGroup>
  <Contents>
    <VideoContent VideoMode=""Live"" Camera=""{cameraGuid}"" />
  </Contents>
</TileContentGroup>";

Workspace.Sdk.ActionManager.DisplayInTile(MONITOR_ID, TILE_ID, xml);

Each tile in a TilePage has a TileState that exposes the tile's current content. Access tile states through TilePage.States:

var tilePage = Workspace.Monitors[0].ActivePage as TilePage;
if (tilePage != null)
{
    foreach (TileState state in tilePage.States)
    {
        ContentGroup content = state.Content;
        if (content is EntityContentGroup entityGroup)
        {
            Guid entityId = entityGroup.EntityId;
        }
    }
}

Set content on a tile by assigning to TileState.Content:

var service = Workspace.Services.Get<IContentBuilderService>();
ContentGroup contentGroup = service.Build(entityGuid);

var tilePage = Workspace.Monitors[0].ActivePage as TilePage;
if (tilePage != null && contentGroup != null)
{
    tilePage.States[0].Content = contentGroup;
}

Use TilePattern.Create to define tile layouts programmatically:

// Simple 2x2 grid
TilePattern pattern = TilePattern.Create(2, 2);

// Custom layout: 3x3 grid where the second tile spans 2x2
var rowSpans = new List<uint> { 1, 2, 1, 1, 1, 1 };
var columnSpans = new List<uint> { 1, 2, 1, 1, 1, 1 };
TilePattern pattern = TilePattern.Create(3, rowSpans, 3, columnSpans);

Assign a tile pattern to a TilePage to change the tile layout:

var tilePage = Workspace.Monitors[0].ActivePage as TilePage;
if (tilePage != null)
{
    tilePage.Pattern = TilePattern.Create(2, 3);
}

TileViewBuilder is a component that provides custom rendering for tile content. When a tile's content changes, the system evaluates registered TileViewBuilder components to find one that supports the content.

1. The tile content changes (through a content builder, TileState.Content, or DisplayInTile)
2. The system creates a TilePluginContext describing the tile state
3. Registered TileViewBuilder components are evaluated via IsSupported(TilePluginContext) in priority order
4. The first builder that returns true creates a TileView via CreateView()
5. The TileView.Update(TilePluginContext) method is called with the current context
6. The TileView.View property provides the WPF UIElement displayed in the tile

TilePluginContext provides the current state of the tile to tile view builders and tile views:

To provide custom rendering, implement TileViewBuilder with two methods: IsSupported to check whether your builder handles the content, and CreateView to return a TileView.

public sealed class ButtonTileViewBuilder : TileViewBuilder
{
    public override string Name => "Button TileView";

    public override Guid UniqueId { get; } = new("E0B61287-FEF3-40A1-937B-7C6CA9F06879");

    public override bool IsSupported(TilePluginContext context)
    {
        if (context.TileState.Content is not EntityContentGroup entityGroup)
            return false;

        var entity = Workspace.Sdk.GetEntity(entityGroup.EntityId) as CustomEntity;
        return entity?.CustomEntityType == MyCustomEntityType.Id;
    }

    public override TileView CreateView()
    {
        return new ButtonTileView(Workspace);
    }
}

Register a TileViewBuilder the same way as a ContentBuilder, in the module's Load method using Workspace.Components.Register.

TileView provides the WPF control displayed in the tile. Override Update to react when the tile content changes.

Built-in content types (VideoContent, MapContent, EntityContent, WebContent, TilePluginContent) have tile views registered by the system. Returning these types from a content builder works without additional setup.

Creating a custom Content subclass requires a matching TileViewBuilder to be registered. Without one, the system does not know how to render the content.