Screenshot Preview


de DLSC - Tipo de producto: Componente / JavaBean / Java Class

Para su comodidad, hemos incluido enlaces a Google Translate para traducir la información del producto que todavía tenemos que traducir. Por favor, tenga en cuenta que traducciones automáticas no siempre son totalmente exactas.

 Con la tecnología de
Por favor note que al menos que se indique lo contrario, esta es la versión en Inglés del producto.


Add Professional Gantt Charts to your Java Applications.  FlexGantt is an advanced Gantt chart user interface component for Swing, which allows its users to interact with project plans and scheduling results. Applications using FlexGantt can customize the Gantt component in almost any way. Not only the rendering and editing of timeline related data can be modified but also the behaviour of the entire component. This is accomplished by pluggable policy implementations, where each policy controls the behaviour of a certain aspect of the Gantt chart. FlexGantt uses a very high abstraction level, which allows it to be applied in various and often very different domains such as project planning (resources, people, tasks), ERP systems, production planning and scheduling applications, manufacturing execution systems or project portfolio management applications.

Opinión media:   basada en: 4 opiniones.
$ 534.43

Nuestros precios Standard están indicados abajo. Inicia una sesión para ver sus precios con descuento.

Precio en

FlexGantt V2.0   *

Añadir a la Cesta $ 534.43 1 Development License  * Entrega a través de Download
Añadir a la Cesta $ 6,961.55 1 Runtime License (Development License Required)  * Entrega a través de Download
Añadir a la Cesta $ 10,710.08 1 Source code License (Development License Required)  * Entrega a través de Download

FlexGantt V2.0 Upgrades   *

Añadir a la Cesta $ 267.22 1 Development License Upgrade from V1.x  * Entrega a través de Download
Añadir a la Cesta $ 3,480.78 1 Runtime License Upgrade from V1.x (Development License Required)  * Entrega a través de Download
Añadir a la Cesta $ 5,355.04 1 Source code License Upgrade from V1.x (Development License Required)  * Entrega a través de Download

FlexGantt V2.0 - Research License   *

Añadir a la Cesta $ 962.84 1 Research License - A special license is available for educational and research purposes (schools, universities). This license includes the standard development and runtime license. This license can not be used to deploy any commercial applications.  * Entrega a través de Download
Añadir a la Cesta $ 481.42 1 Research License Upgrade from V1.x  * Entrega a través de Download

Nuestros precios incluyen servicio técnico de ComponentSource y, para la mayoría de los productos disponibles para descarga, una copia de seguridad en línea y una actualización GRATUITA a la nueva versión si ésta se publica en un período de 30 días después de la compra.  Todas las ventas están sujetas a nuestros Términos y condiciones standard y a nuestra Política de devolución. Por favor, póngase en contacto con nosotros si necesita alguna opción de licencia no ofrecida en la lista, como por ejemplo volumen de licencias y versiones anteriores.

Nuestros precios Standard están indicados arriba. Inicia una sesión para ver sus precios con descuento.


What's new FlexGantt 2.0:

  • Selectable links (relationships)
  • Menu support for links
  • Different relationship types (start - end, end - start, start - start, end - end)
  • Improved graphics performance
  • Animated tree node expand / collapse operations
  • All bug fixes from the 1.1.x releases
  • Macintosh (glossy) style Gantt charts
  • Easier editing of timeline objects (percentage complete, linking)

What's new FlexGantt 1.1.7

  • Improvement - [FLEX-366] - Printing with a custom RelationshipRenderer
  • Bug Fix - [FLEX-358] - Unable to start printings once you have clicked on the cancel button
  • Bug Fix - [FLEX-359] - Memory leak after displaying a Preview dialog
  • Bug Fix - [FLEX-367] - Setting a timezone on ganttchart
  • Bug Fix - [FLEX-368] - tasks are not repainting in real time as I move/resize them


FlexGantt follows the same MVC approach that Swing uses. Several different models are used for various purposes. A calendar model keeps track of holidays and weekends. A paging model supports the user in loading different planning horizons, a bookmark model stores the application and user-defined bookmarks. The primary model, however, the one that feeds the Gantt chart component with data is the Gantt chart model. It is an extension of a tree table model so that it can populate the left hand side of the Gantt chart with data (the left-hand side is a tree table). DLSC FlexGantt also returns so-called timeline objects that are displayed on the right-hand side underneath the timeline. Timeline objects represent activities, tasks, events, milestones, pretty much anything that can be placed on a timeline because it can be associated with a time point or a time span.

DLSC FlexGantt Main Features:

Split Screen / Dual Gantt Chart: A feature required by almost any planning and scheduling application is the ability to keep the data of two different models or two different sections of the same model in synch while scrolling horizontally. The FlexGantt framework includes a Dual Gantt Chart that is capable of doing exactly that. The user can split / unsplit the Gantt chart at any time. A horizontal divider can be used to resize the upper and lower part. Timeline objects can be dragged from one to another.

Bookmarks: Users have become more and more used to the concept of bookmarks. FlexGantt supports them as well and users can use them to quickly adjust the timeline settings, so that a specific time point, granularity and horizon will be shown in the Gantt chart. The defined bookmarks are listed in a menu in the navigation controls. Small preview images of the bookmarked time span will be shown if the control key is down when the user clicked on the menu button.

Layers: FlexGantt uses a very unique layering approach that is known from graphics and mapping applications. Each Gantt chart consists of a set of system layers, which provide the core functionality (e.g. a drawing vertical grid lines) and a set of layers dedicated to rendering timeline objects (activities, events, milestones, ...). The picture below depicts the layer stack. Applications can add as many timeline object layers as they like, allowing them to easily group objects and show or hide them all at once. Layers also support transparency so that overlapping timeline objects can be easily identified.

Drag & Drop Grid : Timeline objects can be dragged and resized horizontally and dragged vertically. An invisible grid can be enabled during these drag & drop operations so that a timeline object can be more easily placed at a specific time. The grid gets controlled by a policy, which means that any kind of grid can be implemented. The default grid policy can be configured to make timeline objects snap to anything from millennium, centuries, decades, years, months, weeks, days, all the way to milliseconds.

Policy controlled behaviour: Scheduling applications vary too a large extent in the way they visualize information, edit data,  and respond to user interaction. DLSC FlexGantt policy framework can be used to tailor the Gantt charts to these variations. Policies are small little decision makers and usually do not contain a lot of code. They are also stateless. In many cases they return flags (booleans) and commands only. The flags are used to control the program flow, while the commands are used to perform the actual modification of data (via a command stack with undo and redo capabilities).

Pluggable Renderers & Editors: Swing defines several renderer and editor classes that are used for its UI components such as tree, table or list. DLSC FlexGantt does the same and defines renderers for tree table cells, column headers, popups, dateline models, timeline objects, eventline objects. Editors are available for tree table cells and timeline objects. A timeline object editor gets displayed in a transparent window within the right:hand side of the Gantt chart (in:place editing, see picture below)

Popups / Annotations: A bar underneath a timeline is a nice representation for an activity but it can only carry a limited number of information due to space restrictions. Popups / annotations that show up when the mouse cursor hovers over such a bar is a nice feature that can display a wealth of additional information that the planner might need to make a scheduling decision. FlexGantt's popups can be customized in the same way that any Swing component can be customized. Different renderers can be mapped to different types of popup objects. The popup objects are looked up from a specialized popup policy. The image below shows the default popup renderer that displays popup objects in its serialized form.

Printing: A plan shown in a Gantt chart is a document and every document needs to be printable. The built-in printing support for FlexGantt lets the user specify a time span and a granularity to be printed (see picture below). The resulting chart can be printed on several pages wide and high.

Relationships: It is quite common that timeline objects have some kind of relationship with each other. Project planning software for example often defines constraints between them. Some examples for constraints are: 'start after', 'finish before', 'same start', 'same end'. FlexGantt can visualize them by drawing lines betwen them. Each application has its own way of visualizing them (different colors and / or line styles for different constraints). By plugging in a custom relationship renderer it is possible to implement any kind of relationship rendering.

Lazy loading: Depending on the application type the volume of data that needs visualization can be rather massiv. In these situations a user interface can only be fast and responsive if it uses a 'lazy loading' approach, which means that data will only be transferred from the server (or database) to the client when the user actually requests it. FlexGantt has been designed from the ground-up to support lazy loading. Example: objects that implement the tree table expansion listener interface will receive an event before the tree expands so that the child nodes of the expanding parent node can be loaded. The paging model is another example for infrastructure that supports lazy loading.

Command framework: FlexGantt provides a small but powerful command framework. It is used to support editing operations that can be undone and redone. The framework consists of commands, a command stack, a command stack listener and a progress monitor. Commands are executed, undone and redone via the Gantt chart, which internally uses a replaceable command stack. Commands are executed in their own thread in order to keep the user interface responsive. Command stack events are issued during the execution of the command. Progress monitors are used to display the progress made by a command. Sub-progress monitors are used for compound commands that consist of several other commands. Once a command has finished execution it will be added to the command stack‘s list of undoable commands. This list will be cleared when a command gets executed that can not be undone. The command framework uses a high level of abstraction so that an already existing command infrastructure (legacy code) can be reused.

Paging: If a scheduling application needs to deal with a large amount of timeline objects then it often makes sense to divide the timeline horizon into several pages / time spans. This way the data gets broken into smaller chunks that the Gantt chart can deal with more easily. The paging model manages the individual pages. It can be queried for the current page, the previous page, the next page, the first page, and the last page. The user interface provides a control that can be used to select individual pages.

Variable row heights: Each row in a FlexGantt chart can have its own height. This feature is very useful when the nodes in the tree table represent different types of objects or if a quantity is associted with each node. In this case the row height can reflect this quantity (e.g. the capacity of a resource).

Multi-column sorting: The tree table on the left:hand side of the Gantt chart supports multi:column sorting, which means that the user can select several tree table columns at the same time and the data in the table will be sorted based on this selection. FlexGantt uses a quicksort algorithm for fast sorting and supports ascending and descending sorting.

Customizable Timeline: Each application has its own requirements for the timeline. Some require the week of the year to be shown next to the date, others want to show the number of the day in the year (for example 'day 241'). The timeline has been designed with flexibility in mind. Its model can be replaced, its renderers can be replaced, even the entire timeline can be substituted with a custom subclass.

Calendar Model : The calendar model provides data for the Gantt chart related to weekends, holidays, or any other kind of special time span. Entries in the calendar model are rendered across the entire height of the layer container (right:hand side). The most prominent example for the use of the calendar model is the definition of those days that are considered weekend. The background of weekend days will grayed out.

Autoscrolling: If a FlexGantt chart updates its 'time now / system time' frequently then it sometimes makes sense to make the application focus on this time. When autoscrolling is enabled then the time now cursor (a vertical dashed line) will remain in the center of the layer container even when time progresses. This is a very useful feature when an application has more of a monitoring function then an interactive scheduling function.

Multiline: The multiline feature enables a Gantt chart to display timeline objects within the same row but above and below each other. This way timeline objects that would otherwise overlap each other can be displayed without problems. 

Búsqueda de productos

Escriba palabras de búsqueda:



Categoría principal

Productos relacionados

Categorias relacionadas

Noticias relacionadas

View All Related News... 

La Tienda de Software para Profesionales de IT‎

Como distribuidores oficiales, ComponentSource ofrece cómodas compras centralizadas de más de 250 editores de software especializados en desarrollo de aplicaciones y operaciones.

Más Información | Sobre Nosotros

Ahorro sobre desarrollo

Lea nuestro Libro Blanco sobre como calcular
el Retorno sobre la Inversión

Líneas de código: 100,000
Hombre-mes: 100
Costo Recursos Humanos: $500,000

Funciones Requeridas:

Esfuerzo por 1000 líneas de código:

Costo Mensual de Recursos Humanos :

Galería de capturas de pantalla

Haga clic para obtener una vista previa completa

Captura de pantalla FlexGantt - JavaBean / Java Library - V2.0 Captura de pantalla FlexGantt - JavaBean / Java Library - V2.0 Captura de pantalla FlexGantt - JavaBean / Java Library - V2.0 Captura de pantalla FlexGantt - JavaBean / Java Library - V2.0 Captura de pantalla FlexGantt - JavaBean / Java Library - V2.0
Award Award