Screens Reference
In Lowgile, screens are object types used to define the application’s user interface. They control how data is displayed, how users interact with the system, and how workflows are triggered throughout the application.
The platform supports several screen types, each designed for a specific role in the UI.
Screens can:
- Display and edit data
- Capture user input
- Trigger actions and workflows
- Embed reusable UI components
- Control how information is presented throughout the application
Create a screen
Section titled “Create a screen”Screens are created in the Lowgile platform’s Design area:
- Path: Design → Object types → Screen
To create a screen:
- Navigate to Design → Object types → Screen
- Click + Add screen
- Enter an ID (for example
PurchaseRequestCreate) - The screen editor opens
Screen editor overview
Section titled “Screen editor overview”The screen editor provides the tools needed to design the layout, configure components, and define screen behaviour.
Layout area
Section titled “Layout area”The layout area is the main canvas where you design the structure of the screen.
Typical tasks include:
- Adding and arranging UI components
- Defining screen structure
- Organizing reusable layout sections
Properties panel
Section titled “Properties panel”The properties panel is used to configure selected components and control their behaviour.
Common configuration tasks include:
- Configuring components
- Binding data
- Defining expressions
- Controlling component behaviour
Actions and logic
Section titled “Actions and logic”The actions and logic layer defines how the screen responds to user interaction.
Common patterns include:
- Buttons
- Event handlers
- Workflow actions
- Expressions and conditional behaviour
Screen variables
Section titled “Screen variables”Screens can define variables that store data during user interaction.
Common variable types include:
- Local variables created and managed within the screen
- Input variables used to pass data into the screen
These variables are commonly used to:
- Initialize new objects
- Store user input
- Share data between parent and embedded screens
- Pass workflow or process data into a screen
Screen composition
Section titled “Screen composition”Screens are often composed by embedding other screens.
For example, a parent screen can:
- Initialize a data object
- Embed an include screen
- Pass data into the embedded screen using input variables
This approach allows:
- Reuse of UI components
- Separation of responsibilities between screens
- Consistent data handling across the application
Insight
Screen composition is one of the core patterns used to build modular and reusable Lowgile applications.
Screen types
Section titled “Screen types”Lowgile applications typically use three main screen types.
| Screen type | Purpose |
|---|---|
| Layout screens | Define the overall page structure (e.g. header, sidebar, main content area) |
| Include screens | Reusable screens embedded inside other screens to display or edit shared UI and data |
| Functional screens | User-facing screens that contain UI elements, actions, and workflow logic |
Note
See Default screens and layouts for prebuilt screens included in new modules.
Layout screens
Section titled “Layout screens”Layout screens define the overall web page structure for the application. They typically contain shared regions such as a header, sidebar, navigation, and main content area. Functional screens are linked to the layout so they display within the defined page structure.
Use layout screens when you need to:
- Create a consistent application page structure,
- Provide shared navigation, headers, sidebars, or framing elements, or
- Display functional screens within a shared application layout.
Include screens
Section titled “Include screens”Include screens are reusable screens embedded inside other screens to display or edit shared UI and data. They still have a layout, but they are usually designed to be placed inside another screen rather than used as a full standalone page.
Use include screens when:
- The same data or UI appears in multiple places
- You want to maintain content in one location
- You need a clean, embeddable component
Insight
Include screens promote reusable UI design. Updating the include screen automatically updates every screen where it is embedded.
Functional screens
Section titled “Functional screens”Functional screens are the main user-facing screens in an application. They allow users to view data, capture input, trigger actions, and interact with workflows.
Functional screens commonly:
- Display and edit transactional data,
- Execute actions or processes, and
- Interact with workflows and tasks.
Use functional screens when you need to:
- Capture user input,
- Display, create, or update data, and
- Trigger actions, workflows, or processes.
Screen composition patterns
Section titled “Screen composition patterns”Screens are often composed using multiple types:
- A layout screen provides structure,
- A functional screen handles user interaction, and
- Include screens provide reusable components within the UI.
Using layout, include, and functional screens together helps keep applications modular, reusable, and consistent.