@cplace/test-mcp-server 1.0.0 → 1.1.0

package/dist/widget-specifications/_research_from_ga_products/cf-platform-connectedTableFilter/research.md

@@ -0,0 +1,468 @@
+# Research: cf.platform.connectedTableFilter Widget
+
+## Widget Overview
+
+**Widget ID:** `cf.platform.connectedTableFilter`
+
+**Repository:** main
+
+**Definition Class:** `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/ConnectedTableFilterWidgetDefinition.java`
+
+**Icon:** `fa-filter` (Font Awesome filter icon)
+
+---
+
+## 1-2 Sentence Description
+
+The Connected Table Filter widget displays and manages the active filters of a connected table widget, providing a visual summary of applied filters and interactive controls to add, edit, or remove individual filters. It acts as a companion widget that synchronizes with any table on the same page, offering users a dedicated UI element to understand and modify the current filter state without cluttering the table itself.
+
+---
+
+## Purpose and Core Functionality
+
+### What This Widget Does
+
+The `cf.platform.connectedTableFilter` widget provides a **dedicated filter management interface** for table widgets in cplace. Instead of embedding filter controls directly within a table, this widget:
+
+1. **Displays active filters** - Shows a human-readable list of all currently applied filters from the connected table
+2. **Provides filter controls** - Offers buttons to add new filters, edit existing ones, or remove them individually
+3. **Synchronizes automatically** - Listens for table refresh events and updates its display when filters change
+4. **Renders filter values** - Converts technical filter criteria into user-friendly text (e.g., shows "Project Status: Active" instead of raw filter data)
+
+### Problem It Solves
+
+When working with filtered tables, users often need to:
+- Understand **what filters are currently active** without examining the table's filter dialog
+- **Quickly remove specific filters** without opening the full filter interface
+- Have a **persistent visual indicator** of the filter state
+- **Separate the filter UI from the data display** for cleaner page layouts
+
+The Connected Table Filter widget solves these problems by providing a standalone filter control panel that can be positioned anywhere on the page, independent of the table widget itself.
+
+---
+
+## Use Cases
+
+### Primary Use Cases
+
+1. **Dashboard Filter Summary**
+   - **Scenario:** A dashboard page contains multiple tables and charts, all filtered by the same criteria
+   - **Usage:** Place a Connected Table Filter widget at the top of the page to show the master filter state
+   - **Benefit:** Users can see all active filters at a glance and modify them from a central location
+
+2. **Compact Table Views**
+   - **Scenario:** A table widget is embedded in a narrow column or compact layout
+   - **Usage:** Use the Connected Table Filter widget separately to avoid overcrowding the table header
+   - **Benefit:** Keeps the table display clean while maintaining full filter functionality
+
+3. **Multi-Widget Coordination**
+   - **Scenario:** A page contains a table plus related connected widgets (charts, metrics, etc.)
+   - **Usage:** The filter widget serves as the control center for the entire connected widget family
+   - **Benefit:** Changes to filters update all connected visualizations simultaneously
+
+4. **Filter Documentation**
+   - **Scenario:** Users need to understand or document the current view configuration
+   - **Usage:** The filter widget provides a persistent, visible record of applied filters
+   - **Benefit:** Reduces confusion about why certain data is or isn't visible
+
+5. **Quick Filter Access**
+   - **Scenario:** Users frequently add or remove specific filters while analyzing data
+   - **Usage:** The widget's "Add Filter" button and per-filter remove buttons enable rapid iteration
+   - **Benefit:** Faster workflow compared to repeatedly opening the table's filter dialog
+
+### When to Use This Widget
+
+Choose the Connected Table Filter widget when:
+- You want to **separate filter controls from the table** for layout reasons
+- The page has **multiple connected widgets** that share the same filter state
+- Users need **high visibility of active filters** without interacting with the table
+- You're building a **dashboard or analytical interface** where filter state is critical context
+
+### When NOT to Use This Widget
+
+Avoid this widget when:
+- The table already provides adequate filter visibility
+- The page is simple with only one table and no space constraints
+- Filters are rarely used or don't need prominent display
+- You want filters embedded directly in the table interface
+
+---
+
+## Configuration Concepts
+
+### Main Configuration Options
+
+The widget has a **minimal, focused configuration** with a single required setting:
+
+#### 1. Table Widget ID (Required)
+
+**Configuration Attribute:** `TABLE_WIDGET_ID`
+
+**Type:** String (single value, required)
+
+**Purpose:** Specifies which table widget this filter widget connects to
+
+**How It Works:**
+- References another widget on the same page by its widget ID
+- Uses dynamic enumeration to list all available table widgets in the current context
+- The enumeration is provided by `ConnectedTableWidgetsEnumerationProvider`
+
+**Example:**
+```java
+// In configuration:
+.put(WidgetTypes.CONNECTED_TABLE_FILTER.TABLE_WIDGET_ID, "projectsTable")
+
+// This connects to a table widget with ID "projectsTable" on the same page
+```
+
+**Important Notes:**
+- The referenced table widget must exist on the same page
+- The widget ID is case-sensitive
+- If the table widget is removed or renamed, the filter widget will lose its connection
+
+### Configuration Inheritance
+
+The `TABLE_WIDGET_ID` attribute is inherited from `ABSTRACT_CONNECTED_TABLE_WIDGET`, which is the base type for all "connected" widgets. This means the configuration pattern is consistent across the entire connected widget family.
+
+### No Additional Customization Needed
+
+Unlike many other widgets, the Connected Table Filter widget doesn't require configuration for:
+- **Filter types** - Automatically handles all filter types supported by the connected table
+- **Display format** - Uses standard rendering logic from `FiltersSubstitution`
+- **UI behavior** - Standard interaction model (add/edit/remove) is built-in
+- **Styling** - Inherits standard cplace widget styling
+
+This simplicity makes the widget **easy to configure** while still being **fully functional**.
+
+---
+
+## Technical Architecture
+
+### Backend Components
+
+#### Widget Definition
+- **File:** `ConnectedTableFilterWidgetDefinition.java`
+- **Location:** `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/`
+- **Purpose:** Registers the widget with cplace and defines its icon
+
+#### Content Handler
+- **File:** `LoadConnectedTableFilterWidgetContentHandler.java`
+- **Location:** `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/handler/widgets/`
+- **Purpose:** POST handler that loads and returns filter content
+- **Process:**
+  1. Receives request with component identifier
+  2. Retrieves table specification
+  3. Delegates to `FiltersSubstitution` for filter rendering
+  4. Returns HTML markup
+
+#### Filter Rendering Logic
+- **File:** `FiltersSubstitution.java`
+- **Location:** `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/handler/widgets/`
+- **Purpose:** Converts technical filter data into human-readable display
+- **Features:**
+  - Handles exact value filters, range filters, full-text search, and custom filters
+  - Renders filter values with proper localization
+  - Displays up to 10 filter attributes with "..." for overflow
+  - Generates tooltips showing full filter values
+
+#### Base Handler
+- **File:** `AbstractConnectedTableHandler.java`
+- **Location:** `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/handler/widgets/`
+- **Purpose:** Provides shared logic for all connected widgets
+- **Functionality:** Table connection handling, search integration
+
+### Frontend Components
+
+#### TypeScript Directive
+- **File:** `cplaceConnectedTableFilter.ts`
+- **Location:** `cf.cplace.platform/assets/ts/directives/`
+- **Controller:** `TableFilterCtrl`
+- **Key Methods:**
+  - `setTableWidgetId()` - Establishes connection to table widget
+  - `showFilterDialog()` - Emits event to open filter dialog
+  - `removeFilter(columnName)` - Removes specific filter
+  - `showFilterDialogAndSelectFilterColumn(columnName)` - Opens dialog for specific column
+  - `toggleSearchInputIsActive()` - Toggles search input
+  - `reloadContent()` - Refreshes filter display when table changes
+
+#### Widget Template
+- **File:** `connectedTableFilterWidgetDefinition.htm`
+- **Location:** `cf.cplace.platform/src/main/resources/cf/cplace/platform/frontend/widgets/`
+- **Directive:** `cplace-connected-table-filter`
+- **Dynamic Content:** Uses `cplace-swappable` for live updates
+
+#### Content Template
+- **File:** `loadConnectedTableFilterWidgetContent.htm`
+- **Location:** `cf.cplace.platform/src/main/resources/cf/cplace/platform/frontend/handler/widgets/`
+- **Elements:**
+  - Filter button with badge (shows as primary when filters exist)
+  - List of active filters with tooltips
+  - Remove button for each filter
+  - Edit button for each filter
+
+### Data Flow
+
+1. **Initialization:**
+   - Angular directive loads with configured `tableWidgetId`
+   - `setTableWidgetId()` establishes connection
+
+2. **Filter Display:**
+   - Directive calls `LoadConnectedTableFilterWidgetContentHandler` via POST
+   - Handler retrieves table's filter state
+   - `FiltersSubstitution` generates human-readable HTML
+   - `cplace-swappable` updates DOM
+
+3. **Filter Modification:**
+   - User clicks "Add Filter" → `showFilterDialog()` emits event
+   - User clicks filter remove button → `removeFilter()` called
+   - User clicks filter edit → `showFilterDialogAndSelectFilterColumn()` called
+   - Table widget processes the change
+   - Table emits refresh event
+   - Filter widget's `reloadContent()` updates display
+
+4. **Synchronization:**
+   - Widget listens for table refresh events
+   - Automatically reloads content when table filters change
+   - Ensures filter display always matches table state
+
+### Supported Filter Types
+
+Based on `FiltersSubstitution.java`, the widget handles:
+
+1. **Exact Value Filters** - Match specific attribute values
+2. **Range Filters** - Numeric or date ranges (min/max)
+3. **Full-Text Search** - Free text search queries
+4. **Custom Filters** - Plugin-defined filter types
+5. **Multi-Value Filters** - Multiple values for the same attribute
+
+Each filter type is rendered with appropriate formatting:
+- Values are shown with proper localization
+- Ranges show "from X to Y" format
+- Long values are truncated with tooltips
+- Multiple values are comma-separated
+
+---
+
+## Relationships with Other Widgets
+
+### Connected Widget Family
+
+The `cf.platform.connectedTableFilter` widget is part of the **connected widget ecosystem**, which includes:
+
+#### Other Connected Widgets:
+- **`cf.platform.connectedBarChart`** - Visualizes table data as bar chart
+- **`cf.platform.connectedPieChart`** - Visualizes table data as pie chart
+- **`cf.platform.connectedMatrix`** - Displays 2D matrix view of table data
+- **`cf.platform.connectedSingleAttribute`** - Shows single attribute from selected table row
+- **`cf.platform.connectedAttributesGroup`** - Shows multiple attributes from selected table row
+
+#### Source Widgets (Tables):
+- **`cf.platform.embeddedSearchAsTable`** - Table view of search results
+- **`cf.platform.embeddedSearchAsList`** - List view of search results
+
+### How Connected Widgets Work Together
+
+All connected widgets share the same architectural pattern:
+
+1. **Single Source of Truth:** A table widget (embedded search) serves as the data source
+2. **One-to-Many Relationship:** Multiple connected widgets can reference the same table
+3. **Shared Configuration:** All use `TABLE_WIDGET_ID` to establish the connection
+4. **Synchronized State:** When the table's filter, sort, or selection changes, all connected widgets update
+
+### Typical Page Layout Pattern
+
+```
+┌─────────────────────────────────────────────┐
+│  Connected Table Filter Widget              │
+│  [Add Filter] [Status: Active] [Type: Bug]  │
+└─────────────────────────────────────────────┘
+
+┌──────────────────────┐ ┌───────────────────┐
+│  Embedded Search     │ │  Connected Bar    │
+│  Table (Source)      │ │  Chart            │
+│  [Table with data]   │ │  [Visualization]  │
+└──────────────────────┘ └───────────────────┘
+
+┌──────────────────────┐ ┌───────────────────┐
+│  Connected Pie Chart │ │  Connected Matrix │
+│  [Visualization]     │ │  [2D View]        │
+└──────────────────────┘ └───────────────────┘
+```
+
+In this layout:
+- The **table** is the master data source
+- The **filter widget** controls the table's filter state
+- All **visualization widgets** automatically update when filters change
+- Users have a **unified experience** across all widgets
+
+### Dependency Notes
+
+- **Prerequisites:** Requires at least one table widget on the same page
+- **Widget ID Dependency:** The table widget's ID must be stable (not change)
+- **Event System:** Relies on cplace's widget event system for synchronization
+- **No Circular Dependencies:** Filter widget reads from table but doesn't create circular update loops
+
+---
+
+## Implementation Examples
+
+### Basic Configuration Example
+
+From test code in `ConnectedTableWidgetsTestHandler.java`:
+
+```java
+// Configure a connected table filter widget
+Map<String, Object> filterWidgetConfig = new HashMap<>();
+filterWidgetConfig.put(
+    WidgetTypes.CONNECTED_TABLE_FILTER.TABLE_WIDGET_ID,
+    "type1TableWidget"  // References a table widget with this ID
+);
+
+// The table widget "type1TableWidget" must exist on the same page
+```
+
+### Typical Use Case Flow
+
+1. **Page Author Creates Layout:**
+   - Adds an embedded search table widget with ID "projectsTable"
+   - Adds a connected table filter widget
+   - Configures filter widget with `TABLE_WIDGET_ID = "projectsTable"`
+   - Optionally adds other connected widgets (charts, etc.) with the same table reference
+
+2. **User Interacts:**
+   - User sees filter widget showing current filters (or "Add Filter" if none)
+   - Clicks "Add Filter" button
+   - Filter dialog opens (managed by table widget)
+   - User selects attribute and sets criteria
+   - Filter is applied to table
+   - Filter widget automatically updates to show new filter
+   - All other connected widgets refresh with filtered data
+
+3. **Filter Management:**
+   - User clicks remove button on a specific filter
+   - That filter is removed from table
+   - Filter widget updates display
+   - User clicks edit button on a filter
+   - Filter dialog opens with that filter pre-selected
+   - User modifies criteria
+   - Filter widget reflects changes
+
+---
+
+## Key Insights and Design Decisions
+
+### Design Philosophy
+
+1. **Separation of Concerns**
+   - Filter state lives in the table widget (single source of truth)
+   - Filter widget is a **view** of that state, not a separate data store
+   - This prevents sync issues and simplifies the architecture
+
+2. **Minimal Configuration**
+   - Only requires table widget ID
+   - Everything else is automatic (filter types, rendering, behavior)
+   - Makes it easy to add/remove without complex setup
+
+3. **Event-Driven Updates**
+   - Widget doesn't poll for changes
+   - Listens for table refresh events
+   - Efficient and responsive
+
+4. **User-Friendly Display**
+   - Technical filter data is translated to readable text
+   - Tooltips provide full details without cluttering the UI
+   - Localization support for international users
+
+### Technical Decisions
+
+1. **POST-Based Content Loading**
+   - Uses POST instead of GET to handle complex filter state
+   - Allows for larger payloads without URL length limits
+
+2. **HTML Rendering on Backend**
+   - Filter display is generated server-side in Java
+   - Angular directive handles interaction logic
+   - Clear separation of rendering vs. behavior
+
+3. **Inheritance from Abstract Base**
+   - Shares code with other connected widgets
+   - Consistent configuration pattern
+   - Easier to maintain and extend
+
+4. **Dynamic Widget Enumeration**
+   - Table widget dropdown is populated at runtime
+   - Only shows widgets that actually exist on the page
+   - Prevents invalid configurations
+
+### Limitations and Constraints
+
+1. **Same-Page Requirement**
+   - Filter widget and table must be on the same page
+   - Cannot connect to tables on different pages
+   - This is by design for performance and simplicity
+
+2. **Single Table Connection**
+   - Each filter widget connects to exactly one table
+   - For multi-table scenarios, need multiple filter widgets
+   - Or use one table as the master and connect others as needed
+
+3. **No Custom Filter UI**
+   - Filter dialog is standard cplace filter interface
+   - Cannot customize filter UI through this widget
+   - Extension would require modifying table widget, not filter widget
+
+4. **Display Limit**
+   - Shows up to 10 filter attributes
+   - Additional filters shown as "..."
+   - This prevents UI overflow but may hide information
+
+---
+
+## Related Documentation
+
+### Source Code Locations
+
+| Component | Path |
+|-----------|------|
+| Widget Definition | `main/cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/ConnectedTableFilterWidgetDefinition.java` |
+| Content Handler | `main/cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/handler/widgets/LoadConnectedTableFilterWidgetContentHandler.java` |
+| Filter Rendering | `main/cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/handler/widgets/FiltersSubstitution.java` |
+| Base Handler | `main/cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/handler/widgets/AbstractConnectedTableHandler.java` |
+| TypeScript Directive | `main/cf.cplace.platform/assets/ts/directives/cplaceConnectedTableFilter.ts` |
+| Widget Template | `main/cf.cplace.platform/src/main/resources/cf/cplace/platform/frontend/widgets/connectedTableFilterWidgetDefinition.htm` |
+| Content Template | `main/cf.cplace.platform/src/main/resources/cf/cplace/platform/frontend/handler/widgets/loadConnectedTableFilterWidgetContent.htm` |
+| Type Definition | `main/cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/templating/WidgetTypes.java` |
+
+### Related Widget Documentation
+
+To fully understand the connected widget ecosystem, also review:
+- `cf.platform.embeddedSearchAsTable` - The primary source table widget
+- `cf.platform.connectedBarChart` - Example of visualization widget using same pattern
+- Abstract base classes for connected widgets
+
+---
+
+## Summary
+
+The `cf.platform.connectedTableFilter` widget is a **specialized UI component** that provides dedicated filter management for table widgets. It solves the common problem of filter visibility and control by offering a standalone interface that can be positioned anywhere on a page.
+
+**Key Characteristics:**
+- **Simple Configuration:** Only requires table widget ID
+- **Automatic Synchronization:** Updates when table filters change
+- **User-Friendly Display:** Shows filters in human-readable format
+- **Interactive Controls:** Add, edit, and remove filters directly
+- **Part of Ecosystem:** Works seamlessly with other connected widgets
+
+**Best Use Cases:**
+- Dashboards with multiple filtered views
+- Compact table layouts where space is limited
+- Analytical interfaces where filter state is critical context
+- Multi-widget pages that share filter state
+
+**Architecture Highlights:**
+- Backend rendering with frontend interaction logic
+- Event-driven updates for efficiency
+- Shared base class with other connected widgets
+- Minimal configuration for ease of use
+
+This widget exemplifies cplace's approach to **modular, connected UI components** that work together to create rich, interactive analytical interfaces while maintaining clean separation of concerns and simple configuration.

package/dist/widget-specifications/_research_from_ga_products/cf-platform-customRichStringAttribute/research.md

@@ -0,0 +1,120 @@
+# Widget Research: cf.platform.customRichStringAttribute
+
+## Widget Overview
+
+**Widget ID:** `cf.platform.customRichStringAttribute`
+
+**Widget Name:** Richstring Attribute
+
+**Repository:** main
+
+**Definition Class:** `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/CustomRichStringAttributeWidgetDefinition.java`
+
+## Purpose
+
+### Short Description
+The Custom Rich String Attribute widget displays a single rich text attribute from a custom entity, providing formatted text rendering with optional widget frame display.
+
+### Core Functionality
+This widget is designed to display rich text (formatted text) content stored in custom attributes of type RichString. It renders the attribute value with its formatting intact and provides control over whether to display the widget within a frame or frameless for seamless content integration.
+
+## Use Cases
+
+### Primary Use Case: Rich Text Content Display
+Display formatted text content from custom entity attributes, such as:
+- **Descriptions and documentation** - Show formatted project descriptions, requirements documentation, or detailed explanations
+- **Formatted notes and comments** - Display user-entered rich text notes with styling preserved
+- **HTML content rendering** - Present rich text content that includes formatting like bold, italic, lists, links, and other HTML elements
+- **Detailed information sections** - Show attribute content that requires formatting for readability (headings, bullet points, etc.)
+
+### When to Use This Widget
+- When you need to display a RichString attribute value from a custom entity
+- When the content includes formatting that needs to be preserved and rendered
+- When you want to present formatted text content without requiring user interaction for editing
+- When you need flexible display options (with or without a widget frame)
+
+### Comparison to Related Widgets
+This widget is specifically for **RichString attributes** and differs from:
+- **Single Attribute Widget** (`cf.platform.singleAttribute`) - More generic, handles multiple attribute types but may not render rich text formatting as effectively
+- **Attributes Group Widget** - Displays multiple attributes together, while this widget focuses on a single rich text attribute
+- **Connected Single Attribute Widget** - Works with table selections, while this widget displays attributes from the embedding entity directly
+
+## Configuration Concepts
+
+### Main Configuration Options
+
+#### 1. Attribute Selection
+**Configuration:** `ATTRIBUTE_NAME` (required)
+- **Purpose:** Specifies which RichString attribute from the custom entity to display
+- **Type:** Dynamic enumeration of RichString attributes
+- **Provider:** `CustomRichStringAttributeEnumerationProvider`
+- **Constraint:** Only attributes with `RichStringConstraint` are available for selection
+- **Behavior:** The widget dynamically retrieves available RichString attributes from the type definition of the entity where it's embedded
+
+#### 2. Frame Display
+**Configuration:** `SHOW_FRAME` (optional, default: true)
+- **Purpose:** Controls whether the widget displays with a visible frame/border or as frameless content
+- **Type:** Boolean
+- **Default Value:** `true`
+- **Use Cases:**
+  - `true` - Display with frame: Useful when the widget should be visually distinct as a separate component, includes the attribute's localized name as the title
+  - `false` - Frameless display: Integrates the content seamlessly into the page layout without visual separation, useful for inline content
+
+### Display Behavior
+
+#### Title Generation
+The widget automatically uses the attribute's localized display name as the title when a frame is shown:
+- Retrieves the type definition of the embedding entity
+- Looks up the attribute definition by the configured attribute name
+- Uses the attribute's localized name as the widget title
+- If the attribute or type definition cannot be found, no title is displayed
+
+#### Content Rendering
+The widget displays the rich text content using the attribute's built-in `show()` method with:
+- `noLabel` - The attribute label is not displayed separately (handled by widget title if frame is shown)
+- `modalEditing="false"` - Modal editing is disabled for display-only context
+- Content is rendered with formatting preserved
+
+## Technical Context
+
+### Dependencies and Prerequisites
+- **Embedding Context:** Must be embedded within a custom entity (implements `CustomEntity` interface)
+- **Attribute Type Requirement:** The selected attribute must have a `RichStringConstraint` type constraint
+- **Embedding Validation:** Widget checks it is embedded as a widget (not in other contexts) via `checkIsEmbeddedAsWidget()`
+
+### Architecture Notes
+- **Configuration Type:** `cf.platform.customRichStringAttribute` (defined in `WidgetTypes.CUSTOM_RICH_STRING_ATTRIBUTE`)
+- **Template:** Uses `customRichStringAttributeWidgetDefinition.htm` for rendering
+- **Scope Object:** Returns the custom attribute value (or dummy with no defaults if not found) for template context
+- **Icon:** Uses `fa-pen-square` FontAwesome icon in widget configuration UI
+- **App Context:** Part of the Platform plugin (`PlatformPlugin.INSTANCE().platformApp`)
+
+### Related Components
+- **Enumeration Provider:** `CustomRichStringAttributeEnumerationProvider` - Filters and provides only RichString attributes for configuration
+- **Base Class:** `WidgetDefinition` - Standard cplace widget definition infrastructure
+- **Template Substitution:** Uses `ContentWidgetTemplateSubstitution` for rendering with frame/frameless support
+
+## Implementation Notes
+
+### Key Methods
+1. **`getContentSubstitution()`** - Creates the template substitution with:
+   - Frame visibility control
+   - Scope object (custom attribute value)
+   - Dynamic title generation from attribute definition
+
+2. **`checkEmbeddableIn()`** - Validates the widget can only be embedded in entities as a widget component
+
+3. **`getConfigurationType()`** - Returns the widget configuration type definition with ATTRIBUTE_NAME and SHOW_FRAME options
+
+### Template Logic
+The widget template uses conditional substitution based on `showFrame`:
+- When frame is shown: Renders with title and frame using `show(noLabel,modalEditing="false",editViaWidget)`
+- When frameless: Renders content only using `show(noLabel,modalEditing="false")`
+
+## Research Sources
+
+- Widget Definition: `/main/cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/CustomRichStringAttributeWidgetDefinition.java`
+- Configuration Type: `/main/cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/templating/WidgetTypes.java` (lines 1112-1136)
+- Enumeration Provider: `/main/cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/CustomRichStringAttributeEnumerationProvider.java`
+- Widget Template: `/main/cf.cplace.platform/src/main/resources/cf/cplace/platform/frontend/widgets/customRichStringAttributeWidgetDefinition.htm`
+- Localization: `/main/cf.cplace.platform/src/main/resources/cf/cplace/platform/messages_en.properties`