| /** |
| * |
| * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation |
| * |
| * |
| * This copyright notice shows up in the generated Java code |
| * |
| */ |
| |
| package org.eclipse.osbp.xtext.reportdsl.jvmmodel |
| |
| import com.google.inject.Inject |
| import com.ibm.icu.util.ULocale |
| import com.vaadin.data.Container.Filter |
| import com.vaadin.server.Sizeable.Unit |
| import com.vaadin.server.StreamResource |
| import com.vaadin.ui.AbstractComponent |
| import com.vaadin.ui.BrowserFrame |
| import com.vaadin.ui.Button |
| import com.vaadin.ui.HorizontalLayout |
| import java.io.ByteArrayOutputStream |
| import java.io.PrintStream |
| import java.util.ArrayList |
| import java.util.Locale |
| import java.util.UUID |
| import org.eclipse.birt.report.model.api.IDesignEngine |
| import org.eclipse.birt.report.model.api.OdaDataSetHandle |
| import org.eclipse.birt.report.model.api.StructureFactory |
| import org.eclipse.birt.report.model.api.command.ContentException |
| import org.eclipse.birt.report.model.api.command.CustomMsgException |
| import org.eclipse.birt.report.model.api.core.IModuleModel |
| import org.eclipse.birt.report.model.api.elements.structures.CachedMetaData |
| import org.eclipse.birt.report.model.api.elements.structures.ComputedColumn |
| import org.eclipse.birt.report.model.api.elements.structures.OdaResultSetColumn |
| import org.eclipse.birt.report.model.api.metadata.DimensionValue |
| import org.eclipse.birt.report.model.elements.interfaces.IDataSetModel |
| import org.eclipse.e4.core.di.extensions.EventUtils |
| import org.eclipse.e4.core.services.events.IEventBroker |
| import org.eclipse.emf.ecore.EObject |
| import org.eclipse.emf.ecore.resource.Resource |
| import org.eclipse.osbp.dsl.entity.xtext.extensions.NamingExtensions |
| import org.eclipse.osbp.dsl.semantic.common.types.LPackage |
| import org.eclipse.osbp.dsl.semantic.entity.LEntityAttribute |
| import org.eclipse.osbp.eventbroker.EventBrokerMsg |
| import org.eclipse.osbp.ui.api.report.IReportProvider |
| import org.eclipse.osbp.utils.entityhelper.DataType |
| import org.eclipse.osbp.utils.vaadin.ViewLayoutManager |
| import org.eclipse.osbp.xtext.action.common.IToolbarAction |
| import org.eclipse.osbp.xtext.basic.generator.BasicDslGeneratorUtils |
| import org.eclipse.osbp.xtext.datamartdsl.DatamartCube |
| import org.eclipse.osbp.xtext.datamartdsl.DatamartDefinition |
| import org.eclipse.osbp.xtext.datamartdsl.DatamartEntity |
| import org.eclipse.osbp.xtext.datamartdsl.DatamartProperty |
| import org.eclipse.osbp.xtext.datamartdsl.DatamartRole |
| import org.eclipse.osbp.xtext.datamartdsl.DatamartTask |
| import org.eclipse.osbp.xtext.datamartdsl.jvmmodel.DatamartDSLJvmModelInferrer |
| import org.eclipse.osbp.xtext.i18n.DSLOutputConfigurationProvider |
| import org.eclipse.osbp.xtext.i18n.I18NKeyGenerator |
| import org.eclipse.osbp.xtext.i18n.I18NModelGenerator |
| import org.eclipse.osbp.xtext.reportdsl.AutoText |
| import org.eclipse.osbp.xtext.reportdsl.DatamartTable |
| import org.eclipse.osbp.xtext.reportdsl.DatamartTableProperty |
| import org.eclipse.osbp.xtext.reportdsl.Element |
| import org.eclipse.osbp.xtext.reportdsl.Grid |
| import org.eclipse.osbp.xtext.reportdsl.Image |
| import org.eclipse.osbp.xtext.reportdsl.Label |
| import org.eclipse.osbp.xtext.reportdsl.PageFooter |
| import org.eclipse.osbp.xtext.reportdsl.PageHeader |
| import org.eclipse.osbp.xtext.reportdsl.PageTemplate |
| import org.eclipse.osbp.xtext.reportdsl.Report |
| import org.eclipse.osbp.xtext.reportdsl.ReportDesignTemplate |
| import org.eclipse.osbp.xtext.reportdsl.ReportModel |
| import org.eclipse.osbp.xtext.reportdsl.ReportPackage |
| import org.eclipse.osbp.xtext.reportdsl.Style |
| import org.eclipse.osbp.xtext.reportdsl.SubSubTitle |
| import org.eclipse.osbp.xtext.reportdsl.SubTitle |
| import org.eclipse.osbp.xtext.reportdsl.Text |
| import org.eclipse.osbp.xtext.reportdsl.Title |
| import org.eclipse.osbp.xtext.reportdsl.common.BaseReport |
| import org.eclipse.osbp.xtext.reportdsl.common.BirtEngine |
| import org.eclipse.osbp.xtext.reportdsl.common.DataTypes |
| import org.eclipse.osbp.xtext.reportdsl.common.OdaConnProperties |
| import org.eclipse.osbp.xtext.reportdsl.common.attribute.Attribute |
| import org.eclipse.osbp.xtext.reportdsl.common.attribute.Width |
| import org.eclipse.osbp.xtext.reportdsl.common.item.BodyItem |
| import org.eclipse.osbp.xtext.reportdsl.common.item.ContainerItem |
| import org.eclipse.osbp.xtext.reportdsl.common.item.GridItem |
| import org.eclipse.osbp.xtext.reportdsl.common.item.ImageItem |
| import org.eclipse.osbp.xtext.reportdsl.common.item.PageFooterItem |
| import org.eclipse.osbp.xtext.reportdsl.common.item.PageHeaderItem |
| import org.eclipse.xtext.generator.IFileSystemAccess |
| import org.eclipse.xtext.naming.IQualifiedNameProvider |
| import org.eclipse.xtext.xbase.compiler.GeneratorConfig |
| import org.eclipse.xtext.xbase.compiler.ImportManager |
| import org.osgi.service.event.Event |
| import org.osgi.service.event.EventHandler |
| |
| class ReportModelGenerator extends I18NModelGenerator { |
| @Inject extension IQualifiedNameProvider |
| @Inject extension DatamartDSLJvmModelInferrer datamartInferrer |
| @Inject extension NamingExtensions |
| @Inject extension BasicDslGeneratorUtils |
| |
| @Inject |
| @Extension |
| private DataType dtType; |
| |
| static var designEngine = null |
| |
| override void doGenerate(Resource input, IFileSystemAccess fsa) { |
| addTranslatables('''«BaseReport.CAPTION_I18NKEY_SAVE_PDF»,«BaseReport.CAPTION_I18NKEY_PRINT_PDF»''') |
| super.doGenerate(input, fsa) |
| } |
| |
| def dispatch void internalDoGenerate(ReportModel orgModel, IFileSystemAccess fsa) { |
| designEngine = BirtEngine.createDesignEngine() |
| for (pkg:orgModel.pckg) { |
| for (report : pkg.reports) { |
| try { |
| generateReportFile(pkg, report, fsa) |
| } |
| catch (Exception e) { |
| e.printStackTrace |
| } |
| } |
| } |
| } |
| |
| private def void generateReportFile(ReportPackage pckg, Report report, IFileSystemAccess fsa) { |
| if (report.design instanceof ReportDesignTemplate) { |
| generateReportRoleFile(pckg, report, null, fsa) |
| for(role : report.datamartRef.roles) { |
| generateReportRoleFile(pckg, report, role, fsa) |
| } |
| } |
| } |
| |
| private def void generateReportRoleFile(ReportPackage pckg, Report report, DatamartRole role, IFileSystemAccess fsa) { |
| var workSet = new ReportGeneratorWorkSet() |
| workSet.generator = this |
| workSet.report = report |
| workSet.role = role |
| // --- generate full path name to the report design file to be generated --- |
| var template = report.design as ReportDesignTemplate |
| var pckgName = pckg.fullyQualifiedName.toString |
| var pckgNamePath = pckgName.replaceAll("\\.","/") |
| var filename = '''«report.name»«IF role!=null»«role.assignedRole.name»«ENDIF».rptdesign''' |
| var fullpath = '''«pckgNamePath»/«filename»''' |
| |
| // --- get managing BIRT instances --- |
| var session = (designEngine as IDesignEngine).newSessionHandle(ULocale.forLocale(Locale.getDefault())) |
| // --- Create a new report design --- |
| workSet.design = session.createDesign() |
| // --- The element factory creates instances of the various BIRT elements --- |
| workSet.factory = workSet.design.getElementFactory() |
| // set the i18n property resources |
| workSet.design.setIncludeResource("i18n/I18N") |
| // set the requested media for this report |
| workSet.requestedMedia = report.media |
| |
| // --- generate a master page --- |
| generateMasterPage(report.datamartRef, workSet, report.pageTemplate, template.header, template.footer) |
| // --- add the master datamart --- |
| // if (report.datamartRef != null) { |
| addDatamartSourceAndSet(report.datamartRef, workSet, null, null) |
| // } |
| |
| var body = new BodyItem(workSet) |
| generateItems(report.datamartRef, workSet, body, template.detail.elements) |
| |
| // --- generate an output stream to receive the BIRT generated report design --- |
| var baos = new ByteArrayOutputStream() |
| try { |
| workSet.design.getModule().prepareToSave(); |
| workSet.design.getModule().getWriter().write(baos); |
| workSet.design.getModule().onSave(); |
| } |
| catch (Exception e) { |
| baos = new ByteArrayOutputStream() |
| e.printStackTrace(new PrintStream(baos)) |
| } |
| |
| // --- generated output stream to the file --- |
| fsa.generateFile(fullpath, DSLOutputConfigurationProvider.DEFAULT_REPORT_OUTPUT, baos.toString()) |
| } |
| |
| // def SessionHandle newSessionHandle(IDesignEngine engine, ULocale locale) { |
| // return engine.newSessionHandle(locale) |
| // } |
| |
| private def generateMasterPage(DatamartDefinition datamart, ReportGeneratorWorkSet workSet, PageTemplate pageTemplate, PageHeader pageHeader, PageFooter pageFooter) { |
| // Note: The report will fail to load in the BIRT designer unless you create a master page. |
| var header = pageHeader |
| var footer = pageFooter |
| if (header == null) { |
| header = pageTemplate.header |
| } |
| if (footer == null) { |
| footer = pageTemplate.footer |
| } |
| var masterPage = workSet.factory.newSimpleMasterPage(pageTemplate.name); //$NON-NLS-1$ |
| masterPage.setPageType(pageTemplate.size.name().toLowerCase); |
| masterPage.setOrientation(pageTemplate.orientation.name().toLowerCase) |
| masterPage.topMargin.setValue(new DimensionValue(pageTemplate.topMarginValue, pageTemplate.topMarginUnit.name().toLowerCase)) |
| masterPage.leftMargin.setValue(new DimensionValue(pageTemplate.leftMarginValue, pageTemplate.leftMarginUnit.name().toLowerCase)) |
| masterPage.bottomMargin.setValue(new DimensionValue(pageTemplate.bottomMarginValue, pageTemplate.bottomMarginUnit.name().toLowerCase)) |
| masterPage.rightMargin.setValue(new DimensionValue(pageTemplate.rightMarginValue, pageTemplate.rightMarginUnit.name().toLowerCase)) |
| if (header != null) { |
| masterPage.setShowHeaderOnFirst(header.showOnFirst) |
| masterPage.headerHeight.setValue(new DimensionValue(header.heightValue, header.heightUnit.name().toLowerCase)) |
| generateItems(datamart, workSet, new PageHeaderItem(workSet, masterPage), header.elements) |
| } |
| if (footer != null) { |
| masterPage.setShowFooterOnLast(footer.showOnLast) |
| masterPage.footerHeight.setValue(new DimensionValue(footer.heightValue, footer.heightUnit.name().toLowerCase)) |
| generateItems(datamart, workSet, new PageFooterItem(workSet, masterPage), footer.elements) |
| } |
| workSet.design.getMasterPages().add(masterPage); |
| } |
| |
| private def addDatamartSourceAndSet(DatamartDefinition datamart, ReportGeneratorWorkSet workSet, String alias, DatamartProperty[] hiddens) { |
| // --- generate the Data Source --- |
| var dataSourceName = Utilities.getDataSourceName(alias, datamart).toString |
| var odsourceh = workSet.factory.newOdaDataSource(dataSourceName, BaseReport.DATASOURCE_EXTENSION_ID); |
| odsourceh.getElement().setID(workSet.design.getModule().getNextID()); |
| workSet.design.getModule().addElementID(odsourceh.getElement()); |
| workSet.design.getModule().add(odsourceh.getElement(), IModuleModel.DATA_SOURCE_SLOT); |
| |
| // --- generate the Data Set connected to the Data Source --- |
| var dataSetName = Utilities.getDataSetName(alias, datamart).toString |
| var odseth = workSet.factory.newOdaDataSet(dataSetName, BaseReport.DATASOURCE_EXTENSION_ID.concat(".dataSet")); |
| workSet.dataSets.put(dataSetName, odseth) |
| odseth.getElement().setID(workSet.design.getModule().getNextID()); |
| odseth.setProperty(OdaConnProperties.DATAMART_BUNDLENAME, Utilities.getBundleName(datamart)); |
| odseth.setProperty(OdaConnProperties.DATAMART_CLASSNAME, getDatamartClassName(alias, datamart)); |
| odseth.setProperty(OdaConnProperties.DATAMART_DATASOURCE, odsourceh.getElement().getName()); |
| odseth.setProperty(OdaConnProperties.DATAMART_DATASOURCENAME, dataSourceName); |
| odseth.setProperty(OdaConnProperties.DATAMART_DATASETNAME, dataSetName); |
| // --- add additional informations to the Data Set --- |
| switch (datamart.source) { |
| DatamartCube: |
| addDatamartCubeResultSet(workSet, odseth, dataSetName, datamart) |
| DatamartEntity: |
| addDatamartEntityResultSet(workSet, odseth, dataSetName, datamart) |
| DatamartTask: |
| System.err.println("DatamartTask ... todo") |
| } |
| workSet.design.getModule().addElementID(odseth.getElement()); |
| workSet.design.getModule().add(odseth.getElement(), IModuleModel.DATA_SET_SLOT); |
| } |
| |
| private def addDatamartCubeResultSet(ReportGeneratorWorkSet workSet, OdaDataSetHandle odseth, String dataSetName, DatamartDefinition datamart) { |
| System.err.println("DatamartCube ... todo") |
| |
| var cube = datamart.source as DatamartCube; |
| var selectColumns = "" |
| var cmd = new CachedMetaData() |
| var sd = new ArrayList<OdaResultSetColumn>() |
| var cc = new ArrayList<ComputedColumn>() |
| |
| // var position = 0 |
| // // --- at first all navigations --- |
| // for (navigation : entity.navigations) { |
| // for (property : navigation.datamartEntity.properties) { |
| // if ((hiddens == null) || !hiddens.contains(property)) { |
| // position = position+1 |
| // addDatamartProperty(sd, cc, property, position) |
| // } |
| // } |
| // } |
| // // --- at last the "pure" data properties --- |
| // for (property : entity.properties) { |
| // if ((hiddens == null) || !hiddens.contains(property)) { |
| // position = position+1 |
| // addDatamartProperty(sd, cc, property, position) |
| // } |
| // } |
| // workSet.putResultSetColumns(dataSetName, sd) |
| // workSet.putComputedColumns(dataSetName, cc) |
| // for (cc1 : cc) { |
| // if (selectColumns.empty) { |
| // selectColumns = cc1.getName(); |
| // } |
| // else { |
| // selectColumns = selectColumns+","+cc1.getName(); |
| // } |
| // } |
| |
| odseth.setProperty("queryText", ('''select «selectColumns» from «datamart.name»''').toString()) |
| cmd.setProperty(IDataSetModel.RESULT_SET_PROP, sd) |
| odseth.setProperty(IDataSetModel.CACHED_METADATA_PROP, cmd) |
| odseth.getElement().setProperty(IDataSetModel.RESULT_SET_PROP, sd) |
| } |
| |
| private def addAllDatamartProperties(ReportGeneratorWorkSet workSet, ArrayList<OdaResultSetColumn> sd, ArrayList<ComputedColumn> cc, EObject container) { |
| switch container { |
| DatamartEntity: { |
| // --- at first all navigations --- |
| for (navigation : container.navigations) { |
| navigation.eAllContents.forEach[element | |
| addAllDatamartProperties(workSet, sd, cc, element) |
| ] |
| } |
| // --- if no explicit properties are set --- |
| if (container.properties.isEmpty) { |
| for (attribute : container.entityRef.allAttributes) { |
| if (!attribute.isId && !attribute.isUuid) { |
| if (datamartInferrer.isAuthorized(workSet.role, container.entityRef, attribute.name)) { |
| addDatamartProperty(workSet, sd, cc, attribute) |
| } |
| } |
| } |
| } |
| // --- at last the "pure" data properties --- |
| else { |
| for (property : container.properties) { |
| if (datamartInferrer.isAuthorized(workSet.role, container.entityRef, property.propertyRef.name)) { |
| addDatamartProperty(workSet, sd, cc, property) |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| private def addDatamartEntityResultSet(ReportGeneratorWorkSet workSet, OdaDataSetHandle odseth, String dataSetName, DatamartDefinition datamart) { |
| var selectColumns = "" |
| var cmd = new CachedMetaData() |
| var sd = new ArrayList<OdaResultSetColumn>() |
| var cc = new ArrayList<ComputedColumn>() |
| |
| workSet.fPosition = 0 |
| addAllDatamartProperties(workSet, sd, cc, datamart.source) |
| workSet.putResultSetColumns(dataSetName, sd) |
| workSet.putComputedColumns(dataSetName, cc) |
| for (cc1 : cc) { |
| if (selectColumns.empty) { |
| selectColumns = cc1.getName(); |
| } |
| else { |
| selectColumns = selectColumns.concat(",").concat(cc1.getName()); |
| } |
| } |
| odseth.setProperty("queryText", ('''select «selectColumns» from «datamart.name»''').toString()) |
| cmd.setProperty(IDataSetModel.RESULT_SET_PROP, sd) |
| odseth.setProperty(IDataSetModel.CACHED_METADATA_PROP, cmd) |
| odseth.getElement().setProperty(IDataSetModel.RESULT_SET_PROP, sd) |
| } |
| |
| private def addDatamartProperty(ReportGeneratorWorkSet workSet, ArrayList<OdaResultSetColumn> sd, ArrayList<ComputedColumn> cc, DatamartProperty property) { |
| addDatamartProperty(workSet, sd, cc, property.propertyRef) |
| } |
| |
| private def addDatamartProperty(ReportGeneratorWorkSet workSet, ArrayList<OdaResultSetColumn> sd, ArrayList<ComputedColumn> cc, LEntityAttribute attribute) { |
| // --- general information about the column --- |
| var etype = dtType.getBasicType(attribute) |
| var dataType = DataTypes.typeFor(etype) |
| if (dataType == DataTypes.ANY) { |
| dataType = DataTypes.typeFor(attribute.type) // ??? warum ANY ??? |
| } |
| // see also DatamartDSLJvmInferrer |
| var name = attribute.toColumnName.toLowerCase |
| // --- check for already found column --- |
| for (column : sd) { |
| if (column.columnName.equalsIgnoreCase(name)) { |
| return |
| } |
| } |
| // --- information needed to access via oda --- |
| var st = new OdaResultSetColumn() |
| st.setColumnName(name) |
| st.setProperty("name", name) |
| st.setNativeDataType(dataType.getNativeOdaDataTypeId()) |
| st.setNativeName(name) |
| workSet.fPosition = workSet.fPosition+1 |
| st.setPosition(workSet.fPosition) |
| st.setDataType(dataType.getNativeOdaDataTypeName()) |
| sd.add(st) |
| // --- information needed to access via table --- |
| var cs1 = StructureFactory.createComputedColumn() |
| cs1.setName(name) |
| cs1.setDisplayName(name); |
| cs1.setExpression("dataSetRow[\"".concat(name).concat("\"]")) |
| cs1.setDataType(dataType.getNativeOdaDataTypeName()) |
| cc.add(cs1) |
| } |
| |
| private def getDatamartClassName(String alias, DatamartDefinition datamart) { |
| '''«(datamart.eContainer as LPackage).fullyQualifiedName».«datamart.name»Class''' |
| } |
| |
| public def generateItems(DatamartDefinition datamart, ReportGeneratorWorkSet workSet, ContainerItem container, Element[] elements) { |
| if (elements != null) { |
| for (element : elements) { |
| try { |
| switch (element) { |
| Title: |
| container.addHeader(1, I18NKeyGenerator.key(element.text), element.text.replace("\"",""), element.style) |
| SubTitle: |
| container.addHeader(2, I18NKeyGenerator.key(element.text), element.text.replace("\"",""), element.style) |
| SubSubTitle: |
| container.addHeader(3, I18NKeyGenerator.key(element.text), element.text.replace("\"",""), element.style) |
| Label: |
| container.addLabel(I18NKeyGenerator.key(element.text), element.text.replace("\"",""), element.style) |
| Text: |
| container.addText (I18NKeyGenerator.key(element.text), element.text.replace("\"",""), element.style) |
| AutoText: |
| container.addAutoText (element.type.toString, element.style) |
| DatamartTableProperty: |
| container.addData (element, element.style) |
| Image: |
| addImage( |
| workSet, container, element, null |
| ) |
| DatamartTable: |
| addDatamartTable(datamart, |
| workSet, container, element, |
| new Width("100%") |
| ) |
| Grid: |
| addGrid(datamart, |
| workSet, container, element, null, |
| new Width("100%") |
| ) |
| // TableDsl: |
| // addTable( |
| // workSet, container, element, |
| // new Width("100%") |
| // ) |
| // ChartDsl: |
| // System.err.println("ChartDsl ... todo") |
| } |
| } |
| catch (ContentException ce) { |
| System.err.println('''«ce.class.simpleName»: «ce.localizedMessage»''') |
| } |
| catch (Exception e) { |
| e.printStackTrace |
| } |
| } |
| } |
| } |
| |
| private def addDatamartTable(DatamartDefinition datamart, ReportGeneratorWorkSet workSet, ContainerItem container, DatamartTable datamartTable, Attribute... attributes) { |
| // var datamart = datamartTable.datamartRef |
| var hiddens = new ArrayList<DatamartProperty> |
| for (columnFormatter : datamartTable.detail.columnFormatters) { |
| // if (columnFormatter.hiddens) { |
| // var column = columnFormatter.column |
| // switch (column) { |
| // TableProperty: hiddens.add(column.valueRef) |
| // } |
| // } |
| } |
| var alias = datamartTable.name |
| var dataSetName = Utilities.getDataSetName(alias, datamart).toString |
| var dataSet = workSet.dataSets.get(dataSetName) |
| if (dataSet == null) { |
| addDatamartSourceAndSet(datamart, workSet, alias, hiddens) |
| dataSet = workSet.dataSets.get(dataSetName) |
| } |
| container.addTable(dataSet, datamartTable, workSet.getComputedColumns(dataSetName), datamartTable.groups, datamartTable.detail.style, datamartTable.detail.columnFormatters, datamartTable.style, attributes) |
| } |
| |
| // def addTable(ReportGeneratorWorkSet workSet, Container container, TableDsl tableDsl, Attribute... attributes) { |
| // var datamart = tableDsl.tableRef.source.datamartRef |
| // var hiddens = null as DatamartProperty[]//tableItem.hiddens |
| // var alias = tableDsl.name |
| // var dataSetName = Utilities.getDataSetName(alias, datamart).toString |
| // var dataSet = workSet.dataSets.get(dataSetName) |
| // if (dataSet == null) { |
| // addDatamart(workSet, alias, datamart, hiddens) |
| // dataSet = workSet.dataSets.get(dataSetName) |
| // } |
| // var propertyLookups = new PropertyLookups |
| // var tableInferrer = new TableDSLJvmModelInferrer |
| // tableInferrer.extractPropertyLookups(tableDsl.tableRef, propertyLookups) |
| // container.addTable(dataSet, workSet.getComputedColumns(dataSetName), propertyLookups, attributes) |
| // } |
| |
| private def addImage(ReportGeneratorWorkSet workSet, ContainerItem container, Image imageData, Style style, Attribute... attributes) { |
| var image = new ImageItem( |
| workSet, |
| null, |
| imageData.size.literal, |
| imageData.scale, |
| imageData.sourceType.literal, |
| imageData.filename |
| ) |
| container.add(image, style, attributes) |
| } |
| |
| private def addGrid(DatamartDefinition datamart, ReportGeneratorWorkSet workSet, ContainerItem container, Grid grid, Style style, Attribute... attributes) { |
| var rowCount = grid.rows.length |
| var columnCount = 0 |
| for (row : grid.rows) { |
| columnCount = Math.max(columnCount, row.cells.length) |
| } |
| var gridItem = new GridItem( |
| workSet, |
| columnCount, |
| rowCount |
| ); |
| var rowNo = 0 |
| for (row : grid.rows) { |
| var columnNo = 0 |
| for (cell : row.cells) { |
| generateItems(datamart, workSet, gridItem.getCell(columnNo, rowNo).setColumnSpan(cell.columnspan), cell.elements) |
| columnNo = columnNo+1 |
| } |
| if (row.style != null) { |
| gridItem.applyStyle(rowNo, row.style) |
| } |
| rowNo = rowNo+1 |
| } |
| container.add(gridItem, style, attributes) |
| } |
| |
| override createAppendable(EObject context, ImportManager importManager, GeneratorConfig config) { |
| // required to initialize the needed builder to avoid deprecated methods |
| builder = context.eResource |
| // --------- |
| addImportFor(importManager, _typeReferenceBuilder |
| , ReportGeneratorWorkSet |
| , HorizontalLayout |
| , ViewLayoutManager |
| , BrowserFrame |
| , StreamResource |
| , Unit |
| , Button |
| , com.vaadin.ui.Label |
| , IEventBroker |
| , EventHandler |
| , Event |
| , EventUtils |
| , EventBrokerMsg |
| , CustomMsgException |
| , IReportProvider.Rendering |
| , AbstractComponent |
| , UUID |
| , Filter |
| , IToolbarAction) |
| super.createAppendable(context, importManager, config) |
| } |
| } |
