> ## Documentation Index
> Fetch the complete documentation index at: https://learn.nextedy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# FAQ

> Find answers to common questions about Nextedy GANTT organized by topic.

export const LastReviewed = ({date}) => {
  if (!date) return null;
  const formatted = new Date(`${date}T00:00:00Z`).toLocaleDateString("en-US", {
    year: "numeric",
    month: "long",
    day: "numeric",
    timeZone: "UTC"
  });
  return <p className="mt-10 text-sm text-gray-400 dark:text-zinc-500 not-prose">
      Last reviewed on {formatted}
    </p>;
};

<div className="nx-faq-hub">
  <AccordionGroup>
    <Accordion title="General Questions" description="Product overview, supported browsers, and getting help." icon="circle-question">
      <AccordionGroup>
        <Accordion title="What is Nextedy GANTT?">
          Gantt is a Gantt chart extension for Siemens Polarion ALM that provides interactive project scheduling, resource management, dependency tracking, and visual timeline planning. It embeds directly into Polarion LiveDoc and Wiki pages as a configurable widget, enabling teams to plan and track work items on a visual timeline without leaving the ALM environment.
        </Accordion>

        <Accordion title="What Polarion license types does Gantt support?">
          Gantt delivers standard Polarion widgets, so every Polarion user can access the Gantt widgets. Any Polarion user with the license and permission to edit work items (or Plans) can edit tasks using the Gantt widget. Any Polarion user who can create a LiveDoc report page can configure and set up the Gantt widgets. See [Licensing and User Access](/gantt/getting-started/licensing) for setup details.
        </Accordion>

        <Accordion title="Is the evaluation time limited?">
          Yes, the evaluation period is limited to 30 days from the date of installation. If you need more time, contact Nextedy to request an extended time-limited license. Upon expiration, the software automatically disables itself, and you must obtain a license certificate for continued use.

          <Tip title="Need more evaluation time?">
            Reach out to Nextedy support before your 30-day evaluation expires to request an extension.
          </Tip>
        </Accordion>

        <Accordion title="Can I add multiple Work Items Gantt widgets to a single page?">
          No, currently only one Gantt widget is supported per report page. If you need to display multiple views, create separate Polarion pages for each Gantt widget instance.
        </Accordion>

        <Accordion title="What is the difference between Work Items Gantt and Plans Gantt?">
          Work Items Gantt displays individual Polarion work items as task bars on the Gantt chart, allowing you to schedule, link, and track individual tasks. Plans Gantt displays Polarion Plans as containers, enabling cross-team and release planning views. See [Set Up a Basic Gantt Chart](/gantt/getting-started/setup-basic-gantt) and [Set Up a Plans Gantt Chart](/gantt/getting-started/setup-plans-gantt) for setup instructions.
        </Accordion>

        <Accordion title="What key features does Gantt provide?">
          The table below summarizes the main feature areas available in Gantt:

          | Feature Area  | Description                                                        |
          | ------------- | ------------------------------------------------------------------ |
          | Scheduling    | Auto-scheduling, dependency links, critical path analysis          |
          | Resources     | Resource view, capacity planning, load modes, working calendars    |
          | Visualization | Baselines, configurable columns, timescales, export to PNG         |
          | Editing       | Lightbox inline editor, drag-and-resize task bars, undo/redo       |
          | Scripting     | Item scripts and page scripts for custom colors, markers, behavior |
          | Plans         | Plans Gantt mode for plan-level scheduling and cross-team views    |

          For detailed guidance on each area, browse the [Guides](/gantt/guides/index) and [Concepts](/gantt/concepts/index) sections.
        </Accordion>

        <Accordion title="How do I get started with Gantt?">
          Start by installing the extension following the [Install Gantt](/gantt/getting-started/installation) tutorial, then explore the [demo project](/gantt/getting-started/demo-project) to see a working Gantt chart with pre-configured tasks, dependency links, and resources. The [Getting Started](/gantt/getting-started/index) section walks you through setup step by step.
        </Accordion>

        <Accordion title="Where can I find the full reference documentation?">
          The [Reference](/gantt/reference/index) section contains complete documentation of all widget parameters, administration properties, and configuration options. For task-oriented walkthroughs, visit the [Guides](/gantt/guides/index) section.
        </Accordion>
      </AccordionGroup>
    </Accordion>

    <Accordion title="Scheduling Questions" description="Auto-scheduling, dependency links, critical path, and date calculations." icon="file">
      <AccordionGroup>
        <Accordion title="How does auto-scheduling work?">
          Auto-scheduling automatically updates the start date of dependent tasks based on the end dates of their predecessors. When you move a task or modify a dependency link, all connected successor tasks are rescheduled to satisfy the dependency constraints. You can toggle auto-scheduling on and off using the toolbar button. To set the default state, configure the `nextedy.gantt.default.auto_scheduling` project-level property. See [Create Your First Dependency Link](/gantt/getting-started/first-dependency) for a practical walkthrough.
        </Accordion>

        <Accordion title="Can I mix auto-scheduling and manual scheduling on the same chart?">
          Yes, you can use a combination of techniques to control scheduling at different levels. Set top-level items to `readonly` mode to prevent auto-scheduling from moving them, while allowing child tasks to reschedule automatically. You can also use the `enforceAutoMode` and `blockAutoMode` task-level flags to override the global auto-scheduling setting on individual tasks.

          <Tip title="Hierarchical scheduling strategy">
            For waterfall projects, pin milestone and top-level items using `blockAutoMode`, then let auto-scheduling handle lower-level task dependencies.
          </Tip>
        </Accordion>

        <Accordion title="Does Gantt detect scheduling conflicts when multiple users edit simultaneously?">
          Gantt uses a last-save-wins approach for concurrent editing. There is no built-in real-time conflict detection between simultaneous users. When two users edit the same task, the most recently saved version takes effect. Plan your editing workflows to minimize overlapping changes on the same work items.

          <Warning title="Concurrent editing">
            Coordinate with your team to avoid editing the same tasks simultaneously. The last save always overwrites previous changes.
          </Warning>
        </Accordion>

        <Accordion title="How do dependency links affect task scheduling?">
          Dependency links define finish-to-start relationships between tasks. When auto-scheduling is enabled, moving a predecessor task automatically pushes its successors forward. If a successor's start date is planned before its predecessor finishes, the Gantt chart highlights the conflict visually. You configure dependency link roles using the `dependsRoles` widget parameter.
        </Accordion>

        <Accordion title="What is critical path analysis?">
          Critical path analysis highlights the longest chain of dependent tasks in your project. Tasks on the critical path are visually marked in the Gantt chart so you can identify which tasks directly affect the project end date. Toggle critical path highlighting using the toolbar button. Critical path requires dependency links to be defined between tasks.
        </Accordion>

        <Accordion title="Can I add lag time to dependency links?">
          Yes, dependency links support lag time. Lag allows you to introduce a delay between the end of a predecessor task and the start of its successor. This is useful for modeling real-world delays such as review periods or material procurement lead times.

          <Info title="Verify in application">
            Configure lag values when creating or editing dependency links in the Gantt chart.
          </Info>
        </Accordion>

        <Accordion title="How does hour-precision scheduling work?">
          Hour-precision scheduling switches the Gantt from day-level to hour-and-minute-level task planning. When enabled via the `highPrecision` configuration, task start and end times include specific hours, enabling sub-day scheduling. This mode is required for accurate resource load calculations at hourly granularity. Note that date display in columns automatically adjusts when high-precision mode is active.

          The following table summarizes the key scheduling features and their configuration:

          | Feature               | Configuration                           | Description                                |
          | --------------------- | --------------------------------------- | ------------------------------------------ |
          | Auto-scheduling       | `nextedy.gantt.default.auto_scheduling` | Dependency-driven date recalculation       |
          | Critical path         | Toolbar toggle                          | Highlights longest dependency chain        |
          | Hour precision        | `highPrecision` widget parameter        | Sub-day scheduling with hours/minutes      |
          | Dependency links      | `dependsRoles` widget parameter         | Finish-to-start task relationships         |
          | Block auto-schedule   | `blockAutoMode` per task                | Pins individual tasks against auto changes |
          | Enforce auto-schedule | `enforceAutoMode` per task              | Forces auto-scheduling on individual tasks |
        </Accordion>

        <Accordion title="Can I sort tasks instead of manually reordering them?">
          The Gantt chart does not support manual drag-and-drop task reordering. Instead, use the sort-by-field functionality to order tasks by any configured column such as start date, priority, or work item ID. Configure the sort behavior through the widget parameters.

          <Info title="Verify in application">
            Task sorting is controlled through widget parameter configuration. Check the reference documentation for available sort options.
          </Info>
        </Accordion>
      </AccordionGroup>
    </Accordion>

    <Accordion title="Resource Management Questions" description="Resource view, capacity planning, working calendars, and load modes." icon="file">
      <AccordionGroup>
        <Accordion title="How do I enable the resource view?">
          Enable the resource view by setting the `showResourceView` widget parameter to `true`. This displays a resource allocation panel below the Gantt chart, showing per-resource workload markers across the project timeline. See [View Resource Allocation](/gantt/getting-started/first-resource-view) for a step-by-step setup guide.
        </Accordion>

        <Accordion title="What resource load modes are available?">
          The Gantt resource view supports four load calculation modes controlled by the `resourceLoadMode` configuration property:

          | Mode                  | Value        | Description                                                  |
          | --------------------- | ------------ | ------------------------------------------------------------ |
          | Task count            | `num`        | Shows the number of tasks assigned per resource per day      |
          | Allocated hours       | `time`       | Shows total allocated working hours per resource per day     |
          | Remaining hours       | `remaining`  | Shows remaining available capacity (total minus allocated)   |
          | Allocation percentage | `allocation` | Shows utilization as a percentage, color-coded by load level |

          <Tip>
            Use `allocation` mode to quickly identify overloaded resources. Cells turn red when a resource is allocated beyond their available capacity.
          </Tip>
        </Accordion>

        <Accordion title="How are resource load colors determined?">
          Resource allocation markers use configurable color thresholds defined by the `resourceMarkersColorConfig` property. This configuration includes an `ok` color for within-capacity states and an `over` color for overallocated states. When using allocation mode, cells are color-coded based on whether the resource's utilization exceeds their available working hours.
        </Accordion>

        <Accordion title="Can I hide resources that have no tasks assigned?">
          Yes, use the resource hiding toggle in the toolbar to hide resources with no visible tasks in the current view. This reduces visual clutter when working with large resource pools. The toggle dynamically re-evaluates which resources have active tasks and shows or hides them accordingly.
        </Accordion>

        <Accordion title="How does Gantt calculate resource capacity from working calendars?">
          The Gantt chart uses working calendars to determine available working hours per resource per day. Each resource can have a per-user working calendar assigned via a `calendar` work item type in Polarion. The calendar defines regular weekly hours per weekday in `HH:mm,HH:mm` format, with `-` marking non-working days. Calendars support inheritance, so a child calendar inherits base hours from a parent and can override specific days.

          <Note>
            Working hours for a specific date are resolved in this order: base calendar, then regular weekday hours, then schedule tweaks, then exceptions (time off / time on).
          </Note>
        </Accordion>

        <Accordion title="Can I manage holidays and schedule exceptions in working calendars?">
          Yes, working calendars support three types of exceptions linked via the `affects` link role:

          * **Time off** -- marks specific dates as non-working (holidays, PTO)
          * **Time on** -- marks specific dates as working days (overriding regular non-working days)
          * **Schedule tweak** -- adjusts working hours for a date range without changing the working/non-working status, using `workstart` and `workend` fields

          Exception work items must be linked to the calendar via the `affects` link role for the system to recognize them.
        </Accordion>

        <Accordion title="How do I set up a global working calendar for my project?">
          Configure the `nextedy.gantt.calendarHolder` server property with a Polarion user ID. The system uses the `calendar` work item assigned to that user as the global working calendar. This is useful for establishing organization-wide working hours without assigning calendars to each individual user.

          <Info>
            Ensure the calendar work item has a valid `From` and `To` date range that covers your project's scheduling period.
          </Info>
        </Accordion>

        <Accordion title="Can I assign tasks to teams instead of individual users?">
          Yes, the Gantt supports team-based assignment mode via the `teamAssignments` configuration property. When enabled, the lightbox shows a team picker instead of a user picker for resource assignment. Related properties include `teamCustomField`, `teamAssignmentStartField`, `teamAssignmentEndField`, and `teamAssignmentCapacityField` for defining the team assignment data model.
        </Accordion>
      </AccordionGroup>
    </Accordion>

    <Accordion title="Licensing Questions" description="License types, evaluation periods, and renewal." icon="id-card">
      <AccordionGroup>
        <Accordion title="How long is the evaluation period?">
          The Gantt evaluation period is limited to 30 days from the date of installation. If you need additional time for evaluation, contact Nextedy support to request an extended time-limited license. Upon expiration, the software automatically disables itself until you obtain a valid license certificate.

          <Warning title="Evaluation expiry">
            The Gantt widget will stop functioning after the 30-day evaluation period. Plan your evaluation timeline accordingly and reach out for an extension before it expires.
          </Warning>
        </Accordion>

        <Accordion title="Can I extend my trial license beyond 30 days?">
          Yes, trial licenses can be extended beyond the initial 30-day period. Contact Nextedy support to request a continuation of your evaluation. This is useful when your team needs more time to complete the evaluation process or when procurement timelines are longer than expected.
        </Accordion>

        <Accordion title="What licensing model does Gantt use?">
          Gantt uses a subscription-based licensing model for new licenses. Perpetual licenses are available only as upgrades for existing customers. Edit access is controlled by the `nextedy_gantt_users` group -- members are Editors, everyone else has read-only Reviewer access (see [Licensing and User Access](/gantt/getting-started/licensing)).

          For the technical license-file types (Primary/Secondary Evaluation, Perpetual, Test) and their expiry behavior, see [License Types and Evaluation Periods](/gantt/reference/license-types).
        </Accordion>

        <Accordion title="Can I use my license on multiple Polarion server nodes?">
          Yes, licenses can be used on both nodes of a multi-node Polarion deployment. There is no restriction on deploying your Gantt license across clustered or high-availability Polarion server configurations.
        </Accordion>

        <Accordion title="What happens when my license expires or is invalid?">
          When the Gantt license is invalid or expired, a license status panel appears at the top of the Gantt widget with an appropriate message and contact information. The panel displays one of three states: valid (`ok`), approaching expiry (`warning`), or expired (`expired`). The license status is checked once at startup when the widget loads.
        </Accordion>

        <Accordion title="What is the difference between an expired license and expired maintenance?">
          An expired license prevents the Gantt widget from functioning entirely, displaying a license panel with contact information. Expired maintenance means your license is still active, but you are no longer entitled to software updates or new feature releases. You can continue using the currently installed version, but you cannot upgrade to newer versions until maintenance is renewed.
        </Accordion>

        <Accordion title="Where can I find the license administration settings?">
          You can access the Gantt administration settings by clicking the gear icon in the Gantt widget footer. This opens the administration page where you can view and manage license configuration. The Gantt version number is also displayed in the widget footer for reference.

          For complete licensing setup instructions, see [Licensing and User Access](/gantt/getting-started/licensing).
        </Accordion>
      </AccordionGroup>
    </Accordion>

    <Accordion title="Scripting Questions" description="Config scripts, item scripts, markers, and the Velocity API." icon="file">
      <Info title="Verify in application">
        This page covers the scripting API at a high level. Verify specific script syntax and available variables in the Gantt application and [Reference](/gantt/reference/index) documentation.
      </Info>

      <AccordionGroup>
        <Accordion title="What types of scripts does Gantt support?">
          Gantt supports two types of scripts: **item scripts** and **page scripts**. Item scripts run against individual tasks and can modify their appearance, such as changing task bar colors or adding markers. Page scripts run once when the Gantt chart loads and can modify global behavior, configuration, and register custom editors or markers.
        </Accordion>

        <Accordion title="What can I do with item scripts?">
          Item scripts allow you to customize individual task bars based on work item properties. Common use cases include applying conditional color coding based on status or priority, adding visual markers to specific tasks, and modifying task labels. Item scripts execute on the server side with access to the task data and Polarion work item fields.
        </Accordion>

        <Accordion title="What can I do with page scripts?">
          Page scripts run at page load time and provide access to the Gantt configuration, editor registry, and marker utilities. You can use page scripts to register custom column editors, add timeline markers (such as milestone dates or sprint boundaries), and modify configuration values before the Gantt chart initializes.

          | Script Type | Runs         | Scope               | Common Use Cases                                   |
          | ----------- | ------------ | ------------------- | -------------------------------------------------- |
          | Item script | Per task     | Individual task bar | Color coding, markers, label customization         |
          | Page script | Once at load | Entire Gantt chart  | Custom editors, timeline markers, config overrides |
        </Accordion>

        <Accordion title="How do I add custom markers to the Gantt timeline?">
          Page scripts can add custom vertical line markers to the Gantt timeline using the marker utilities exposed through the scripting API. Markers are commonly used to indicate today's date, milestone deadlines, sprint boundaries, or plan due dates. The "Today" marker is built in and displayed by default.

          <Info title="Verify in application">
            Check the scripting reference for the exact API to add custom markers, including available styling options.
          </Info>
        </Accordion>

        <Accordion title="Can I customize task bar colors using scripts?">
          Yes, item scripts are the primary mechanism for applying conditional task bar colors. You can write logic that reads work item fields (such as status, priority, or a custom field) and returns a CSS color value to apply to the task bar. This lets you visually distinguish different categories of work items on the Gantt chart.
        </Accordion>

        <Accordion title="Can I register custom column editors via scripts?">
          Yes, page scripts can register custom inline column editors through the editor registry. These custom editors appear in the Gantt grid columns and allow users to edit task fields using specialized input controls beyond the default text and date editors.

          <Info title="Verify in application">
            Custom editor registration must occur before the Gantt chart initializes. Refer to the scripting reference for the editor registration API.
          </Info>

          For more on Gantt capabilities, see the [Concepts](/gantt/concepts/index) and [Guides](/gantt/guides/index) sections.
        </Accordion>
      </AccordionGroup>
    </Accordion>

    <Accordion title="Configuration Questions" description="Widget parameters, administration properties, and setup options." icon="gear">
      <Info title="Verify in application">
        This page provides an overview of configuration concepts. Refer to the [Reference](/gantt/reference/index) section for complete property documentation.
      </Info>

      <AccordionGroup>
        <Accordion title="What is the difference between widget parameters and administration properties?">
          Gantt uses two levels of configuration. **Widget parameters** are set per-widget instance on the Polarion page and control the behavior of that specific Gantt chart. **Administration properties** are set globally in the Polarion administration panel and apply to all Gantt widgets across the project or server. Widget parameters take precedence over administration properties when both define the same setting.

          | Configuration Level     | Scope                  | Set Where                     | Example                                 |
          | ----------------------- | ---------------------- | ----------------------------- | --------------------------------------- |
          | Widget parameter        | Per widget instance    | Polarion page widget editor   | `showResourceView`, `readonly`          |
          | Administration property | Project or server-wide | Polarion Administration panel | `nextedy.gantt.default.auto_scheduling` |
        </Accordion>

        <Accordion title="How do I set up field mappings for the Gantt chart?">
          Field mappings tell the Gantt which Polarion work item fields to use for task start dates, end dates, duration, and progress. You need at least two of the three date fields configured: `startField` + `endField`, `startField` + `durationField`, or `endField` + `durationField`. The Gantt validates these mappings at render time and displays an error message if the combination is invalid.

          <Warning title="Required field mappings">
            You must configure at least two of `startField`, `endField`, and `durationField`. The Gantt widget will not render without a valid field mapping combination.
          </Warning>
        </Accordion>

        <Accordion title="How do I configure dependency link roles?">
          Set the **Dependency Role** parameter (`dependsRoles`) to specify which Polarion link role IDs represent finish-to-start dependencies between tasks. Work items connected with these link roles appear as dependency arrows in the Gantt chart. Similarly, use **Parent Role** (`parentRoles`) to define which link roles represent parent-child hierarchical relationships displayed in the Gantt tree structure.
        </Accordion>

        <Accordion title="How do I configure the Gantt to show a specific work item type?">
          The work items shown in the Gantt are selected by the **Work Items** dataset parameter (query, collection, or scope) -- there is no dedicated work item type parameter. Restrict the displayed type by writing the query accordingly, for example `type:workpackage`. See [Work Items Gantt Widget Parameters](/gantt/reference/widget-parameters/work-items-gantt) for the dataset parameter. To control how each work item type renders (as a task bar, summary, or milestone), set the **Gantt Presentation Mode** per type in the **Work Item Types Configuration**.

          <Info title="Verify in application">
            The exact work item type IDs available depend on your Polarion project configuration. Check your project's work item type definitions.
          </Info>
        </Accordion>

        <Accordion title="Can I make the Gantt chart read-only?">
          Yes, enable the **Read-only** parameter (`readonly`) to disable all editing capabilities. This hides the Edit button and prevents drag, resize, and add-task operations. Conversely, enable always-edit mode (`alwaysedit`) if you want the Gantt to always be in edit mode without requiring users to click an Edit button first.
        </Accordion>

        <Accordion title="How do I configure the resource field for task assignment?">
          The **Resource Field** parameter (`resourceField`) specifies which Polarion work item field is used as the assigned resource. This drives both the resource view display and the resource filter functionality. The field can be set to the assignee field, a category field, or a custom field depending on your resource management model.

          For full setup instructions, see [Set Up a Basic Gantt Chart](/gantt/getting-started/setup-basic-gantt) and the [Reference](/gantt/reference/index) documentation.
        </Accordion>
      </AccordionGroup>
    </Accordion>

    <Accordion title="Editing and Saving Questions" description="Lightbox editing, undo/redo, save behavior, and field types." icon="file">
      <Info title="Verify in application">
        This page covers editing workflows at a high level. Consult the [Guides](/gantt/guides/index) section for detailed how-to instructions.
      </Info>

      <AccordionGroup>
        <Accordion title="How do I edit tasks on the Gantt chart?">
          Click the **Edit** button in the Gantt toolbar to enter edit mode. Once in edit mode, you can drag task bars to change dates, resize them to adjust duration, and create dependency links between tasks. All changes are tracked as pending until you explicitly save. If `alwaysedit` is enabled via widget parameters, the Gantt is always in edit mode and no Edit button is shown.
        </Accordion>

        <Accordion title="How do I save my changes?">
          Click the **Save** button in the toolbar to persist all pending changes to Polarion. The save operation sends all modified tasks and dependency links to the server in a single transaction. A progress indicator appears during the save process. If there are no unsaved changes, the save button has no effect.

          | Action          | How                                 | Notes                                     |
          | --------------- | ----------------------------------- | ----------------------------------------- |
          | Enter edit mode | Click **Edit** in toolbar           | Not needed if `alwaysedit` is `true`      |
          | Move a task     | Drag the task bar horizontally      | Changes start and end dates               |
          | Resize a task   | Drag the right edge of the task bar | Changes duration or end date              |
          | Save changes    | Click **Save** in toolbar           | Persists all pending edits to Polarion    |
          | Undo changes    | Use undo in the toolbar             | Multi-step undo of date changes and moves |
        </Accordion>

        <Accordion title="What is the lightbox editor?">
          The lightbox is an inline editing dialog that opens when you double-click a task bar or click the edit icon on a task. It provides form fields for editing task properties such as dates, duration, progress, assigned resources, and custom fields. Changes made in the lightbox are applied to the task when you confirm and are included in the next save operation.
        </Accordion>

        <Accordion title="Can I undo changes before saving?">
          Yes, Gantt supports multi-step undo and redo for task date changes, moves, and resizes. Use the undo/redo controls to step back through your editing history before saving. Once you save, changes are committed to Polarion and can no longer be undone through the Gantt undo feature.

          <Tip title="Undo before saving">
            Always review your changes before clicking Save. Undo is only available for unsaved edits made in the current editing session.
          </Tip>
        </Accordion>

        <Accordion title="What happens if two users edit the same task simultaneously?">
          Gantt uses a last-save-wins approach. There is no real-time conflict detection between concurrent editors. If two users modify the same task, the version saved last overwrites previous changes. Coordinate with your team to avoid editing the same work items at the same time.

          <Warning title="No concurrent edit detection">
            Plan your editing workflows to minimize overlap. The most recently saved version always takes effect.
          </Warning>
        </Accordion>

        <Accordion title="Can I prevent users from editing specific tasks?">
          Yes, set the `readonly` widget parameter to `true` to make the entire Gantt chart read-only. For more granular control, individual tasks can be set to read-only mode, which prevents drag, resize, and edit operations on those specific tasks while keeping the rest of the chart editable.

          <Info title="Verify in application">
            Per-task read-only control may be configured through item scripts or task properties. Check the reference documentation for available options.
          </Info>
        </Accordion>

        <Accordion title="Does the Gantt toolbar have a fullscreen mode?">
          Yes, when the `maximize` widget parameter is set to `true`, a fullscreen toggle button appears in the toolbar. Clicking it expands the Gantt chart to fill the browser window, providing more screen space for viewing and editing large project schedules.

          For editing setup details, see [Set Up a Basic Gantt Chart](/gantt/getting-started/setup-basic-gantt).
        </Accordion>
      </AccordionGroup>
    </Accordion>

    <Accordion title="Visualization and Display Questions" description="Colors, zoom levels, columns, baselines, and export options." icon="palette">
      <Info title="Verify in application">
        This page covers visualization features at a high level. Refer to the [Reference](/gantt/reference/index) section for detailed property documentation.
      </Info>

      <AccordionGroup>
        <Accordion title="How do I compare the current schedule against a baseline?">
          Gantt supports baselines for comparing your current schedule against a saved snapshot. The Compare with History feature allows you to select a historical date, a named baseline, or a specific revision number. When active, baseline bars appear below the actual task bars, showing the originally planned start and end dates alongside the current dates.
        </Accordion>

        <Accordion title="Can I export the Gantt chart as an image?">
          Yes, Gantt provides an export-to-PNG feature accessible from the toolbar. The export panel renders the Gantt chart as an image and provides download and print buttons. You can apply date filtering to control which portion of the schedule is included in the export.

          <Note title="PDF export not supported">
            The Gantt widget cannot be exported to PDF format. Use the PNG export feature for sharing static schedule snapshots.
          </Note>
        </Accordion>

        <Accordion title="How do I customize task bar colors?">
          Task bar colors can be set in two ways. Each work item type has a default color that is automatically applied to its task bars. For more dynamic control, use item scripts to apply conditional color logic based on work item fields such as status, priority, or custom attributes. See [Scripting Questions](/gantt/faq/scripting) for more on item scripts.

          | Method                       | Scope                      | Configuration                                 |
          | ---------------------------- | -------------------------- | --------------------------------------------- |
          | Work item type default color | All tasks of a type        | Polarion work item type settings              |
          | Item script color logic      | Per task, conditional      | Custom item script with color return value    |
          | `color` / `taskColor` field  | Per task, from field value | Map a custom field to the task color property |
        </Accordion>

        <Accordion title="What columns can I display in the Gantt grid?">
          The Gantt grid supports configurable columns with multiple template types including start date, end date, deadline, owner/assignees, duration, progress, and custom columns. The assignee column supports two display modes: `initials` (showing user initials in circles) and `fullname` (showing full names). A special workload column appears when you select a resource in the resource view.
        </Accordion>

        <Accordion title="How do I access the column and display settings menu?">
          Click the hamburger menu icon in the first column header of the Gantt grid. This opens a menu with options for column visibility, timescale selection, and navigation settings. You can show or hide columns and adjust the timescale granularity from this menu.
        </Accordion>

        <Accordion title="Can I hide the Gantt toolbar?">
          Yes, set the `hideToolbar` widget parameter to `true` to hide the entire toolbar. When the toolbar is hidden and you are in edit mode, a floating save button appears as a fallback so you can still save your changes.

          <Info title="Verify in application">
            When using `hideToolbar`, ensure users have an alternative way to access essential functions like save and refresh.
          </Info>
        </Accordion>

        <Accordion title="How do I show only leaf tasks without parent summary rows?">
          Set the `onlyLeafTasks` widget parameter to `true` to display only leaf-level tasks (tasks with no children). Parent summary tasks are hidden from the Gantt chart, giving you a flat view of all actionable work items without the hierarchical grouping.
        </Accordion>

        <Accordion title="What visual indicators show task status?">
          The Gantt chart uses several visual indicators to communicate task status at a glance:

          * **Progress fill** -- the filled portion of each task bar shows completion percentage
          * **Overdue deadlines** -- deadline column values turn red when the task is past due
          * **Risk indicator** -- tasks at risk (past end date) are highlighted with a warning color
          * **Conflict markers** -- tasks with parent-child date range conflicts display a visual conflict indicator
          * **Unplanned indicator** -- tasks with no scheduled dates appear with a special unplanned marker

          For additional display customization, explore the [Guides](/gantt/guides/index) section.
        </Accordion>
      </AccordionGroup>
    </Accordion>
  </AccordionGroup>
</div>

<Note title="How widget parameters are named">
  These FAQs refer to widget parameters by their internal identifier (for example `readonly`, `showResourceView`, `dependsRoles`). In the Polarion page **widget editor** you set them through their Title Case labels -- `readonly` appears as **Read-only**, `showResourceView` as **Show Resource View**, `dependsRoles` as **Dependency Role**, and so on. See [Work Items Gantt Widget Parameters](/gantt/reference/widget-parameters/work-items-gantt) and [Data Mapping Parameters](/gantt/reference/widget-parameters/data-mapping) for the full label-to-identifier reference.
</Note>

<Tip title="Can't find your answer?">
  Check the [Reference](/gantt/reference/index) section for detailed property documentation, or browse the [Guides](/gantt/guides/index) for step-by-step instructions. For additional support, [submit a support ticket](https://support.nextedy.com/support/tickets/new).
</Tip>

<LastReviewed date="2026-07-08" />