net.sf.dynamicreports.jasper.transformation.ConstantTransform Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of dynamicreports-core Show documentation
Show all versions of dynamicreports-core Show documentation
DynamicReports is an open source Java reporting library based on JasperReports. It allows to create dynamic report designs and it doesn't need a visual report designer.
You can very quickly create reports and produce documents that can be displayed, printed or exported into many popular formats such as PDF, Excel, Word and others.
/**
* DynamicReports - Free Java reporting library for creating reports dynamically
*
* Copyright (C) 2010 - 2016 Ricardo Mariaca
* http://www.dynamicreports.org
*
* This file is part of DynamicReports.
*
* DynamicReports is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* DynamicReports is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with DynamicReports. If not, see permissions) {
int permission = 0;
for (PdfPermission pdfPermission : permissions) {
switch (pdfPermission) {
case PRINTING:
return permission | PdfWriter.ALLOW_PRINTING;
case MODIFY_CONTENTS:
return permission | PdfWriter.ALLOW_MODIFY_CONTENTS;
case COPY:
return permission | PdfWriter.ALLOW_COPY;
case MODIFY_ANNOTATIONS:
return permission | PdfWriter.ALLOW_MODIFY_ANNOTATIONS;
case FILL_IN:
return permission | PdfWriter.ALLOW_FILL_IN;
case SCREEN_READERS:
return permission | PdfWriter.ALLOW_SCREENREADERS;
case ASSEMBLY:
return permission | PdfWriter.ALLOW_ASSEMBLY;
case DEGRADED_PRINTING:
return permission | PdfWriter.ALLOW_DEGRADED_PRINTING;
default:
throw new JasperDesignException("PdfPermission " + pdfPermission.name() + " not supported");
}
}
return permission;
}
protected static PdfPrintScalingEnum pdfPrintScaling(PdfPrintScaling pdfPrintScaling) {
switch (pdfPrintScaling) {
case NONE:
return PdfPrintScalingEnum.NONE;
case DEFAULT:
return PdfPrintScalingEnum.DEFAULT;
default:
throw new JasperDesignException("Pdf print scaling " + pdfPrintScaling.name() + " not supported");
}
}
protected static PdfaConformanceEnum pdfaConformance(PdfaConformance pdfaConformance) {
switch (pdfaConformance) {
case NONE:
return PdfaConformanceEnum.NONE;
case PDFA_1A:
return PdfaConformanceEnum.PDFA_1A;
case PDFA_1B:
return PdfaConformanceEnum.PDFA_1B;
default:
throw new JasperDesignException("Pdfa conformance " + pdfaConformance.name() + " not supported");
}
}
public static net.sf.jasperreports.components.barcode4j.OrientationEnum barcodeOrientation(BarcodeOrientation orientation) {
switch (orientation) {
case NONE:
return net.sf.jasperreports.components.barcode4j.OrientationEnum.UP;
case LEFT:
return net.sf.jasperreports.components.barcode4j.OrientationEnum.LEFT;
case RIGHT:
return net.sf.jasperreports.components.barcode4j.OrientationEnum.RIGHT;
case UPSIDE_DOWN:
return net.sf.jasperreports.components.barcode4j.OrientationEnum.DOWN;
default:
throw new JasperDesignException("BarcodeOrientation " + orientation.name() + " not supported");
}
}
public static RotationEnum barbecueRotation(BarcodeOrientation orientation) {
switch (orientation) {
case NONE:
return RotationEnum.NONE;
case LEFT:
return RotationEnum.LEFT;
case RIGHT:
return RotationEnum.RIGHT;
case UPSIDE_DOWN:
return RotationEnum.UPSIDE_DOWN;
default:
throw new JasperDesignException("BarcodeOrientation " + orientation.name() + " not supported");
}
}
public static TextPositionEnum barcodeTextPosition(BarcodeTextPosition textPosition) {
if (textPosition == null) {
return null;
}
switch (textPosition) {
case NONE:
return TextPositionEnum.NONE;
case BOTTOM:
return TextPositionEnum.BOTTOM;
case TOP:
return TextPositionEnum.TOP;
default:
throw new JasperDesignException("BarcodeTextPosition " + textPosition.name() + " not supported");
}
}
public static ChecksumMode barcodeChecksumMode(BarcodeChecksumMode checksumMode) {
if (checksumMode == null) {
return null;
}
switch (checksumMode) {
case AUTO:
return ChecksumMode.CP_AUTO;
case IGNORE:
return ChecksumMode.CP_IGNORE;
case ADD:
return ChecksumMode.CP_ADD;
case CHECK:
return ChecksumMode.CP_CHECK;
default:
throw new JasperDesignException("BarcodeChecksumMode " + checksumMode.name() + " not supported");
}
}
public static SymbolShapeHint barcodeShape(BarcodeShape shape) {
if (shape == null) {
return null;
}
switch (shape) {
case NONE:
return SymbolShapeHint.FORCE_NONE;
case SQUARE:
return SymbolShapeHint.FORCE_SQUARE;
case RECTANGLE:
return SymbolShapeHint.FORCE_RECTANGLE;
default:
throw new JasperDesignException("BarcodeShape " + shape.name() + " not supported");
}
}
public static BaselineAlignment barcodeBaselinePosition(BarcodeBaselinePosition baselinePosition) {
if (baselinePosition == null) {
return null;
}
switch (baselinePosition) {
case TOP:
return BaselineAlignment.ALIGN_TOP;
case BOTTOM:
return BaselineAlignment.ALIGN_BOTTOM;
default:
throw new JasperDesignException("BarcodeBaselinePosition " + baselinePosition.name() + " not supported");
}
}
public static ErrorCorrectionLevelEnum qrCodeErrorCorrectionLevel(QrCodeErrorCorrectionLevel errorCorrectionLevel) {
if (errorCorrectionLevel == null) {
return null;
}
switch (errorCorrectionLevel) {
case L:
return ErrorCorrectionLevelEnum.L;
case M:
return ErrorCorrectionLevelEnum.M;
case Q:
return ErrorCorrectionLevelEnum.Q;
case H:
return ErrorCorrectionLevelEnum.H;
default:
throw new JasperDesignException("QrCodeErrorCorrectionLevel " + errorCorrectionLevel.name() + " not supported");
}
}
public static String barbecueType(BarbecueType barbecueType) {
if (barbecueType == null) {
return null;
}
switch (barbecueType) {
case BARCODE_2OF7:
return "2of7";
case BARCODE_3OF9:
return "3of9";
case BOOKLAND:
return "Bookland";
case CODABAR:
return "Codabar";
case CODE128:
return "Code128";
case CODE128A:
return "Code128A";
case CODE128B:
return "Code128B";
case CODE128C:
return "Code128C";
case CODE39:
return "Code39";
case CODE39_EXTENDED:
return "Code39 (Extended)";
case EAN128:
return "EAN128";
case EAN13:
return "EAN13";
case GLOBAL_TRADE_ITEM_NUMBER:
return "GlobalTradeItemNumber";
case INT_2OF5:
return "Int2of5";
case MONARCH:
return "Monarch";
case NW7:
return "NW7";
case PDF417:
return "PDF417";
case POSTNET:
return "PostNet";
case RANDOM_WEIGHT_UPCA:
return "RandomWeightUPCA";
case SCC14_SHIPPING_CODE:
return "SCC14ShippingCode";
case SHIPMENT_IDENTIFICATION_NUMBER:
return "ShipmentIdentificationNumber";
case SSCC18:
return "SSCC18";
case STD_2OF5:
return "Std2of5";
case UCC128:
return "UCC128";
case UPCA:
return "UPCA";
case USD3:
return "USD3";
case USD4:
return "USD4";
case USPS:
return "USPS";
default:
throw new JasperDesignException("BarbecueType " + barbecueType.name() + " not supported");
}
}
public static LineDirectionEnum lineDirection(LineDirection lineDirection) {
if (lineDirection == null) {
return null;
}
switch (lineDirection) {
case TOP_DOWN:
return LineDirectionEnum.TOP_DOWN;
case BOTTOM_UP:
return LineDirectionEnum.BOTTOM_UP;
default:
throw new JasperDesignException("LineDirection " + lineDirection.name() + " not supported");
}
}
public static String markup(Markup markup) {
if (markup == null) {
return null;
}
switch (markup) {
case NONE:
return "none";
case STYLED:
return "styled";
case RTF:
return "rtf";
case HTML:
return "html";
default:
throw new JasperDesignException("Markup " + markup.name() + " not supported");
}
}
public static LineSpacingEnum lineSpacing(LineSpacing lineSpacing) {
if (lineSpacing == null) {
return null;
}
switch (lineSpacing) {
case SINGLE:
return LineSpacingEnum.SINGLE;
case ONE_AND_HALF:
return LineSpacingEnum.ONE_AND_HALF;
case DOUBLE:
return LineSpacingEnum.DOUBLE;
case AT_LEAST:
return LineSpacingEnum.AT_LEAST;
case FIXED:
return LineSpacingEnum.FIXED;
case PROPORTIONAL:
return LineSpacingEnum.PROPORTIONAL;
default:
throw new JasperDesignException("LineSpacing " + lineSpacing.name() + " not supported");
}
}
public static BreakTypeEnum breakType(BreakType breakType) {
if (breakType == null) {
return null;
}
switch (breakType) {
case PAGE:
return BreakTypeEnum.PAGE;
case COLUMN:
return BreakTypeEnum.COLUMN;
default:
throw new JasperDesignException("BreakType " + breakType.name() + " not supported");
}
}
public static RunDirectionEnum runDirection(RunDirection runDirection) {
if (runDirection == null) {
return null;
}
switch (runDirection) {
case LEFT_TO_RIGHT:
return RunDirectionEnum.LTR;
case RIGHT_TO_LEFT:
return RunDirectionEnum.RTL;
default:
throw new JasperDesignException("RunDirection " + runDirection.name() + " not supported");
}
}
public static CrosstabTotalPositionEnum crosstabTotalPosition(CrosstabTotalPosition totalPosition) {
if (totalPosition == null) {
return CrosstabTotalPositionEnum.NONE;
}
switch (totalPosition) {
case START:
return CrosstabTotalPositionEnum.START;
case END:
return CrosstabTotalPositionEnum.END;
default:
throw new JasperDesignException("CrosstabTotalPosition " + totalPosition.name() + " not supported");
}
}
public static CrosstabPercentageEnum crosstabPercentageType(CrosstabPercentageType percentageType) {
if (percentageType == null) {
return null;
}
switch (percentageType) {
case NONE:
return CrosstabPercentageEnum.NONE;
case GRAND_TOTAL:
return CrosstabPercentageEnum.GRAND_TOTAL;
default:
throw new JasperDesignException("CrosstabPercentageType " + percentageType.name() + " not supported");
}
}
public static SortOrderEnum orderType(OrderType orderType) {
if (orderType == null) {
return null;
}
switch (orderType) {
case ASCENDING:
return SortOrderEnum.ASCENDING;
case DESCENDING:
return SortOrderEnum.DESCENDING;
default:
throw new JasperDesignException("OrderType " + orderType.name() + " not supported");
}
}
public static BucketOrder bucketOrderType(OrderType orderType) {
if (orderType == null) {
return null;
}
switch (orderType) {
case ASCENDING:
return BucketOrder.ASCENDING;
case DESCENDING:
return BucketOrder.DESCENDING;
default:
throw new JasperDesignException("OrderType " + orderType.name() + " not supported");
}
}
public static PositionTypeEnum componentPositionType(ComponentPositionType componentPositionType) {
switch (componentPositionType) {
case FLOAT:
return PositionTypeEnum.FLOAT;
case FIX_RELATIVE_TO_TOP:
return PositionTypeEnum.FIX_RELATIVE_TO_TOP;
case FIX_RELATIVE_TO_BOTTOM:
return PositionTypeEnum.FIX_RELATIVE_TO_BOTTOM;
default:
throw new JasperDesignException("ComponentPositionType " + componentPositionType.name() + " not supported");
}
}
@SuppressWarnings("deprecation")
public static StretchTypeEnum stretchType(StretchType stretchType) {
if (stretchType == null) {
return StretchTypeEnum.NO_STRETCH;
}
switch (stretchType) {
case NO_STRETCH:
return StretchTypeEnum.NO_STRETCH;
case RELATIVE_TO_BAND_HEIGHT:
return StretchTypeEnum.CONTAINER_HEIGHT;
case RELATIVE_TO_TALLEST_OBJECT:
return StretchTypeEnum.ELEMENT_GROUP_HEIGHT;
case ELEMENT_GROUP_HEIGHT:
return StretchTypeEnum.ELEMENT_GROUP_HEIGHT;
case ELEMENT_GROUP_BOTTOM:
return StretchTypeEnum.ELEMENT_GROUP_BOTTOM;
case CONTAINER_HEIGHT:
return StretchTypeEnum.CONTAINER_HEIGHT;
case CONTAINER_BOTTOM:
return StretchTypeEnum.CONTAINER_BOTTOM;
default:
throw new JasperDesignException("StretchType " + stretchType.name() + " not supported");
}
}
public static HyperlinkTypeEnum hyperLinkType(String hyperLinkType) {
if (hyperLinkType == null || !EnumUtils.isValidEnum(HyperLinkType.class, hyperLinkType)) {
return null;
}
HyperLinkType type = HyperLinkType.valueOf(hyperLinkType);
switch (type) {
case NONE:
return HyperlinkTypeEnum.NONE;
case REFERENCE:
return HyperlinkTypeEnum.REFERENCE;
case LOCAL_ANCHOR:
return HyperlinkTypeEnum.LOCAL_ANCHOR;
case LOCAL_PAGE:
return HyperlinkTypeEnum.LOCAL_PAGE;
case REMOTE_ANCHOR:
return HyperlinkTypeEnum.REMOTE_ANCHOR;
case REMOTE_PAGE:
return HyperlinkTypeEnum.REMOTE_PAGE;
default:
throw new JasperDesignException("HyperLinkType " + type.name() + " not supported");
}
}
public static HyperlinkTargetEnum hyperLinkTarget(String hyperLinkTarget) {
if (hyperLinkTarget == null || !EnumUtils.isValidEnum(HyperLinkTarget.class, hyperLinkTarget)) {
return null;
}
HyperLinkTarget target = HyperLinkTarget.valueOf(hyperLinkTarget);
switch (target) {
case NONE:
return HyperlinkTargetEnum.NONE;
case SELF:
return HyperlinkTargetEnum.SELF;
case BLANK:
return HyperlinkTargetEnum.BLANK;
case PARENT:
return HyperlinkTargetEnum.PARENT;
case TOP:
return HyperlinkTargetEnum.TOP;
default:
throw new JasperDesignException("HyperLinkTarget " + target.name() + " not supported");
}
}
public static FooterPositionEnum groupFooterPosition(GroupFooterPosition footerPosition) {
switch (footerPosition) {
case NORMAL:
return FooterPositionEnum.NORMAL;
case COLLATE_AT_BOTTOM:
return FooterPositionEnum.COLLATE_AT_BOTTOM;
case FORCE_AT_BOTTOM:
return FooterPositionEnum.FORCE_AT_BOTTOM;
case STACK_AT_BOTTOM:
return FooterPositionEnum.STACK_AT_BOTTOM;
default:
throw new JasperDesignException("GroupFooterPosition " + footerPosition.name() + " not supported");
}
}
public static SpiderRotationEnum spiderRotation(SpiderRotation rotation) {
if (rotation == null) {
return null;
}
switch (rotation) {
case CLOCKWISE:
return SpiderRotationEnum.CLOCKWISE;
case ANTICLOCKWISE:
return SpiderRotationEnum.ANTICLOCKWISE;
default:
throw new JasperDesignException("SpiderRotation " + rotation.name() + " not supported");
}
}
public static TableOrderEnum tableOrder(TableOrder tableOrder) {
if (tableOrder == null) {
return null;
}
switch (tableOrder) {
case BY_ROW:
return TableOrderEnum.BY_ROW;
case BY_COLUMN:
return TableOrderEnum.BY_COLUMN;
default:
throw new JasperDesignException("TableOrder " + tableOrder.name() + " not supported");
}
}
public static TabStopAlignEnum tabStopAlignment(TabStopAlignment alignment) {
switch (alignment) {
case LEFT:
return TabStopAlignEnum.LEFT;
case CENTER:
return TabStopAlignEnum.CENTER;
case RIGHT:
return TabStopAlignEnum.RIGHT;
default:
throw new JasperDesignException("TabStopAlignment " + alignment.name() + " not supported");
}
}
protected static PrintOrderEnum printOrder(Orientation printOrder) {
switch (printOrder) {
case HORIZONTAL:
return PrintOrderEnum.HORIZONTAL;
case VERTICAL:
return PrintOrderEnum.VERTICAL;
default:
throw new JasperDesignException("PrintOrder " + printOrder.name() + " not supported");
}
}
public static ScaleTypeEnum scaleType(ScaleType scaleType) {
switch (scaleType) {
case ON_BOTH_AXES:
return ScaleTypeEnum.ON_BOTH_AXES;
case ON_DOMAIN_AXIS:
return ScaleTypeEnum.ON_DOMAIN_AXIS;
case ON_RANGE_AXIS:
return ScaleTypeEnum.ON_RANGE_AXIS;
default:
throw new JasperDesignException("ScaleType " + scaleType.name() + " not supported");
}
}
public static org.jfree.ui.RectangleAnchor rectangleAnchor(RectangleAnchor rectangleAnchor) {
switch (rectangleAnchor) {
case CENTER:
return org.jfree.ui.RectangleAnchor.CENTER;
case TOP:
return org.jfree.ui.RectangleAnchor.TOP;
case TOP_LEFT:
return org.jfree.ui.RectangleAnchor.TOP_LEFT;
case TOP_RIGHT:
return org.jfree.ui.RectangleAnchor.TOP_RIGHT;
case BOTTOM:
return org.jfree.ui.RectangleAnchor.BOTTOM;
case BOTTOM_LEFT:
return org.jfree.ui.RectangleAnchor.BOTTOM_LEFT;
case BOTTOM_RIGHT:
return org.jfree.ui.RectangleAnchor.BOTTOM_RIGHT;
case LEFT:
return org.jfree.ui.RectangleAnchor.LEFT;
case RIGHT:
return org.jfree.ui.RectangleAnchor.RIGHT;
default:
throw new JasperDesignException("RectangleAnchor " + rectangleAnchor.name() + " not supported");
}
}
}