Source Code Cross Referenced for JRXmlConstants.java in  » Report » jasperreports-2.0.1 » net » sf » jasperreports » engine » xml » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » Report » jasperreports 2.0.1 » net.sf.jasperreports.engine.xml 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


0001:        /*
0002:         * ============================================================================
0003:         * GNU Lesser General Public License
0004:         * ============================================================================
0005:         *
0006:         * JasperReports - Free Java report-generating library.
0007:         * Copyright (C) 2001-2006 JasperSoft Corporation http://www.jaspersoft.com
0008:         *
0009:         * This library is free software; you can redistribute it and/or
0010:         * modify it under the terms of the GNU Lesser General Public
0011:         * License as published by the Free Software Foundation; either
0012:         * version 2.1 of the License, or (at your option) any later version.
0013:         *
0014:         * This library is distributed in the hope that it will be useful,
0015:         * but WITHOUT ANY WARRANTY; without even the implied warranty of
0016:         * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
0017:         * Lesser General Public License for more details.
0018:         *
0019:         * You should have received a copy of the GNU Lesser General Public
0020:         * License along with this library; if not, write to the Free Software
0021:         * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
0022:         *
0023:         * JasperSoft Corporation
0024:         * 303 Second Street, Suite 450 North
0025:         * San Francisco, CA 94107
0026:         * http://www.jaspersoft.com
0027:         */
0028:        package net.sf.jasperreports.engine.xml;
0029:
0030:        import java.awt.Color;
0031:        import java.util.HashMap;
0032:        import java.util.Map;
0033:
0034:        import net.sf.jasperreports.charts.JRChartAxis;
0035:        import net.sf.jasperreports.charts.JRMeterPlot;
0036:        import net.sf.jasperreports.charts.JRThermometerPlot;
0037:        import net.sf.jasperreports.crosstabs.JRCellContents;
0038:        import net.sf.jasperreports.crosstabs.JRCrosstabMeasure;
0039:        import net.sf.jasperreports.crosstabs.fill.calculation.BucketDefinition;
0040:        import net.sf.jasperreports.engine.JRAlignment;
0041:        import net.sf.jasperreports.engine.JRBreak;
0042:        import net.sf.jasperreports.engine.JRChart;
0043:        import net.sf.jasperreports.engine.JRElement;
0044:        import net.sf.jasperreports.engine.JRExpression;
0045:        import net.sf.jasperreports.engine.JRGraphicElement;
0046:        import net.sf.jasperreports.engine.JRHyperlink;
0047:        import net.sf.jasperreports.engine.JRHyperlinkHelper;
0048:        import net.sf.jasperreports.engine.JRImage;
0049:        import net.sf.jasperreports.engine.JRLine;
0050:        import net.sf.jasperreports.engine.JRPrintText;
0051:        import net.sf.jasperreports.engine.JRReport;
0052:        import net.sf.jasperreports.engine.JRSortField;
0053:        import net.sf.jasperreports.engine.JRTextElement;
0054:        import net.sf.jasperreports.engine.JRVariable;
0055:
0056:        import org.jfree.chart.plot.PlotOrientation;
0057:        import org.jfree.chart.renderer.xy.XYBubbleRenderer;
0058:        import org.jfree.data.time.Day;
0059:        import org.jfree.data.time.Hour;
0060:        import org.jfree.data.time.Millisecond;
0061:        import org.jfree.data.time.Minute;
0062:        import org.jfree.data.time.Month;
0063:        import org.jfree.data.time.Quarter;
0064:        import org.jfree.data.time.Second;
0065:        import org.jfree.data.time.Week;
0066:        import org.jfree.data.time.Year;
0067:
0068:        /**
0069:         * @author Teodor Danciu (teodord@users.sourceforge.net)
0070:         * @version $Id: JRXmlConstants.java 1798 2007-07-30 09:47:58Z teodord $
0071:         */
0072:        public class JRXmlConstants {
0073:
0074:            /**
0075:             *
0076:             */
0077:            private static final String POSITION_TYPE_FLOAT = "Float";
0078:            private static final String POSITION_TYPE_FIX_RELATIVE_TO_TOP = "FixRelativeToTop";
0079:            private static final String POSITION_TYPE_FIX_RELATIVE_TO_BOTTOM = "FixRelativeToBottom";
0080:
0081:            private static Map positionTypeMap = null;
0082:
0083:            public static Map getPositionTypeMap() {
0084:                if (positionTypeMap == null) {
0085:                    positionTypeMap = new HashMap(6);
0086:                    positionTypeMap.put(POSITION_TYPE_FLOAT, new Byte(
0087:                            JRElement.POSITION_TYPE_FLOAT));
0088:                    positionTypeMap
0089:                            .put(
0090:                                    POSITION_TYPE_FIX_RELATIVE_TO_TOP,
0091:                                    new Byte(
0092:                                            JRElement.POSITION_TYPE_FIX_RELATIVE_TO_TOP));
0093:                    positionTypeMap
0094:                            .put(
0095:                                    POSITION_TYPE_FIX_RELATIVE_TO_BOTTOM,
0096:                                    new Byte(
0097:                                            JRElement.POSITION_TYPE_FIX_RELATIVE_TO_BOTTOM));
0098:                    positionTypeMap.put(
0099:                            new Byte(JRElement.POSITION_TYPE_FLOAT),
0100:                            POSITION_TYPE_FLOAT);
0101:                    positionTypeMap.put(new Byte(
0102:                            JRElement.POSITION_TYPE_FIX_RELATIVE_TO_TOP),
0103:                            POSITION_TYPE_FIX_RELATIVE_TO_TOP);
0104:                    positionTypeMap.put(new Byte(
0105:                            JRElement.POSITION_TYPE_FIX_RELATIVE_TO_BOTTOM),
0106:                            POSITION_TYPE_FIX_RELATIVE_TO_BOTTOM);
0107:                }
0108:
0109:                return positionTypeMap;
0110:            }
0111:
0112:            /**
0113:             *
0114:             */
0115:            private static final String MODE_OPAQUE = "Opaque";
0116:            private static final String MODE_TRANSPARENT = "Transparent";
0117:
0118:            private static Map modeMap = null;
0119:
0120:            public static Map getModeMap() {
0121:                if (modeMap == null) {
0122:                    modeMap = new HashMap(4);
0123:                    modeMap.put(MODE_OPAQUE, new Byte(JRElement.MODE_OPAQUE));
0124:                    modeMap.put(MODE_TRANSPARENT, new Byte(
0125:                            JRElement.MODE_TRANSPARENT));
0126:                    modeMap.put(new Byte(JRElement.MODE_OPAQUE), MODE_OPAQUE);
0127:                    modeMap.put(new Byte(JRElement.MODE_TRANSPARENT),
0128:                            MODE_TRANSPARENT);
0129:                }
0130:
0131:                return modeMap;
0132:            }
0133:
0134:            /**
0135:             *
0136:             */
0137:            private static final String COLOR_BLACK = "black";
0138:            private static final String COLOR_BLUE = "blue";
0139:            private static final String COLOR_CYAN = "cyan";
0140:            private static final String COLOR_DARK_GRAY = "darkGray";
0141:            private static final String COLOR_GRAY = "gray";
0142:            private static final String COLOR_GREEN = "green";
0143:            private static final String COLOR_LIGHT_GRAY = "lightGray";
0144:            private static final String COLOR_MAGENTA = "magenta";
0145:            private static final String COLOR_ORANGE = "orange";
0146:            private static final String COLOR_PINK = "pink";
0147:            private static final String COLOR_RED = "red";
0148:            private static final String COLOR_YELLOW = "yellow";
0149:            private static final String COLOR_WHITE = "white";
0150:
0151:            private static Map colorMap = null;
0152:
0153:            public static Map getColorMap() {
0154:                if (colorMap == null) {
0155:                    colorMap = new HashMap(26);
0156:                    colorMap.put(COLOR_BLACK, Color.black);
0157:                    colorMap.put(COLOR_BLUE, Color.blue);
0158:                    colorMap.put(COLOR_CYAN, Color.cyan);
0159:                    colorMap.put(COLOR_DARK_GRAY, Color.darkGray);
0160:                    colorMap.put(COLOR_GRAY, Color.gray);
0161:                    colorMap.put(COLOR_GREEN, Color.green);
0162:                    colorMap.put(COLOR_LIGHT_GRAY, Color.lightGray);
0163:                    colorMap.put(COLOR_MAGENTA, Color.magenta);
0164:                    colorMap.put(COLOR_ORANGE, Color.orange);
0165:                    colorMap.put(COLOR_PINK, Color.pink);
0166:                    colorMap.put(COLOR_RED, Color.red);
0167:                    colorMap.put(COLOR_YELLOW, Color.yellow);
0168:                    colorMap.put(COLOR_WHITE, Color.white);
0169:                    colorMap.put(Color.black, COLOR_BLACK);
0170:                    colorMap.put(Color.blue, COLOR_BLUE);
0171:                    colorMap.put(Color.cyan, COLOR_CYAN);
0172:                    colorMap.put(Color.darkGray, COLOR_DARK_GRAY);
0173:                    colorMap.put(Color.gray, COLOR_GRAY);
0174:                    colorMap.put(Color.green, COLOR_GREEN);
0175:                    colorMap.put(Color.lightGray, COLOR_LIGHT_GRAY);
0176:                    colorMap.put(Color.magenta, COLOR_MAGENTA);
0177:                    colorMap.put(Color.orange, COLOR_ORANGE);
0178:                    colorMap.put(Color.pink, COLOR_PINK);
0179:                    colorMap.put(Color.red, COLOR_RED);
0180:                    colorMap.put(Color.yellow, COLOR_YELLOW);
0181:                    colorMap.put(Color.white, COLOR_WHITE);
0182:                }
0183:
0184:                return colorMap;
0185:            }
0186:
0187:            /**
0188:             *
0189:             */
0190:            private static final String HORIZONTAL_ALIGN_LEFT = "Left";
0191:            private static final String HORIZONTAL_ALIGN_CENTER = "Center";
0192:            private static final String HORIZONTAL_ALIGN_RIGHT = "Right";
0193:            private static final String HORIZONTAL_ALIGN_JUSTIFIED = "Justified";
0194:
0195:            private static Map horizontalAlignMap = null;
0196:
0197:            public static Map getHorizontalAlignMap() {
0198:                if (horizontalAlignMap == null) {
0199:                    horizontalAlignMap = new HashMap(8);
0200:                    horizontalAlignMap.put(HORIZONTAL_ALIGN_LEFT, new Byte(
0201:                            JRAlignment.HORIZONTAL_ALIGN_LEFT));
0202:                    horizontalAlignMap.put(HORIZONTAL_ALIGN_CENTER, new Byte(
0203:                            JRAlignment.HORIZONTAL_ALIGN_CENTER));
0204:                    horizontalAlignMap.put(HORIZONTAL_ALIGN_RIGHT, new Byte(
0205:                            JRAlignment.HORIZONTAL_ALIGN_RIGHT));
0206:                    horizontalAlignMap.put(HORIZONTAL_ALIGN_JUSTIFIED,
0207:                            new Byte(JRAlignment.HORIZONTAL_ALIGN_JUSTIFIED));
0208:                    horizontalAlignMap.put(new Byte(
0209:                            JRAlignment.HORIZONTAL_ALIGN_LEFT),
0210:                            HORIZONTAL_ALIGN_LEFT);
0211:                    horizontalAlignMap.put(new Byte(
0212:                            JRAlignment.HORIZONTAL_ALIGN_CENTER),
0213:                            HORIZONTAL_ALIGN_CENTER);
0214:                    horizontalAlignMap.put(new Byte(
0215:                            JRAlignment.HORIZONTAL_ALIGN_RIGHT),
0216:                            HORIZONTAL_ALIGN_RIGHT);
0217:                    horizontalAlignMap.put(new Byte(
0218:                            JRAlignment.HORIZONTAL_ALIGN_JUSTIFIED),
0219:                            HORIZONTAL_ALIGN_JUSTIFIED);
0220:                }
0221:
0222:                return horizontalAlignMap;
0223:            }
0224:
0225:            /**
0226:             *
0227:             */
0228:            public static Map getTextAlignMap() {
0229:                return getHorizontalAlignMap();
0230:            }
0231:
0232:            /**
0233:             *
0234:             */
0235:            private static final String VERTICAL_ALIGN_TOP = "Top";
0236:            private static final String VERTICAL_ALIGN_MIDDLE = "Middle";
0237:            private static final String VERTICAL_ALIGN_BOTTOM = "Bottom";
0238:
0239:            private static Map verticalAlignMap = null;
0240:
0241:            public static Map getVerticalAlignMap() {
0242:                if (verticalAlignMap == null) {
0243:                    verticalAlignMap = new HashMap(6);
0244:                    verticalAlignMap.put(VERTICAL_ALIGN_TOP, new Byte(
0245:                            JRAlignment.VERTICAL_ALIGN_TOP));
0246:                    verticalAlignMap.put(VERTICAL_ALIGN_MIDDLE, new Byte(
0247:                            JRAlignment.VERTICAL_ALIGN_MIDDLE));
0248:                    verticalAlignMap.put(VERTICAL_ALIGN_BOTTOM, new Byte(
0249:                            JRAlignment.VERTICAL_ALIGN_BOTTOM));
0250:                    verticalAlignMap
0251:                            .put(new Byte(JRAlignment.VERTICAL_ALIGN_TOP),
0252:                                    VERTICAL_ALIGN_TOP);
0253:                    verticalAlignMap.put(new Byte(
0254:                            JRAlignment.VERTICAL_ALIGN_MIDDLE),
0255:                            VERTICAL_ALIGN_MIDDLE);
0256:                    verticalAlignMap.put(new Byte(
0257:                            JRAlignment.VERTICAL_ALIGN_BOTTOM),
0258:                            VERTICAL_ALIGN_BOTTOM);
0259:                }
0260:
0261:                return verticalAlignMap;
0262:            }
0263:
0264:            /**
0265:             *
0266:             */
0267:            private static final String ROTATION_NONE = "None";
0268:            private static final String ROTATION_LEFT = "Left";
0269:            private static final String ROTATION_RIGHT = "Right";
0270:            private static final String ROTATION_UPSIDE_DOWN = "UpsideDown";
0271:
0272:            private static Map rotationMap = null;
0273:
0274:            public static Map getRotationMap() {
0275:                if (rotationMap == null) {
0276:                    rotationMap = new HashMap(6);
0277:                    rotationMap.put(ROTATION_NONE, new Byte(
0278:                            JRTextElement.ROTATION_NONE));
0279:                    rotationMap.put(ROTATION_LEFT, new Byte(
0280:                            JRTextElement.ROTATION_LEFT));
0281:                    rotationMap.put(ROTATION_RIGHT, new Byte(
0282:                            JRTextElement.ROTATION_RIGHT));
0283:                    rotationMap.put(ROTATION_UPSIDE_DOWN, new Byte(
0284:                            JRTextElement.ROTATION_UPSIDE_DOWN));
0285:                    rotationMap.put(new Byte(JRTextElement.ROTATION_NONE),
0286:                            ROTATION_NONE);
0287:                    rotationMap.put(new Byte(JRTextElement.ROTATION_LEFT),
0288:                            ROTATION_LEFT);
0289:                    rotationMap.put(new Byte(JRTextElement.ROTATION_RIGHT),
0290:                            ROTATION_RIGHT);
0291:                    rotationMap.put(
0292:                            new Byte(JRTextElement.ROTATION_UPSIDE_DOWN),
0293:                            ROTATION_UPSIDE_DOWN);
0294:                }
0295:
0296:                return rotationMap;
0297:            }
0298:
0299:            /**
0300:             *
0301:             */
0302:            private static final String BREAK_TYPE_PAGE = "Page";
0303:            private static final String BREAK_TYPE_COLUMN = "Column";
0304:
0305:            private static Map breakTypeMap = null;
0306:
0307:            public static Map getBreakTypeMap() {
0308:                if (breakTypeMap == null) {
0309:                    breakTypeMap = new HashMap(4);
0310:                    breakTypeMap.put(BREAK_TYPE_PAGE, new Byte(
0311:                            JRBreak.TYPE_PAGE));
0312:                    breakTypeMap.put(BREAK_TYPE_COLUMN, new Byte(
0313:                            JRBreak.TYPE_COLUMN));
0314:                    breakTypeMap.put(new Byte(JRBreak.TYPE_PAGE),
0315:                            BREAK_TYPE_PAGE);
0316:                    breakTypeMap.put(new Byte(JRBreak.TYPE_COLUMN),
0317:                            BREAK_TYPE_COLUMN);
0318:                }
0319:
0320:                return breakTypeMap;
0321:            }
0322:
0323:            /**
0324:             *
0325:             */
0326:            private static final String RUN_DIRECTION_LTR = "LTR";
0327:            private static final String RUN_DIRECTION_RTL = "RTL";
0328:
0329:            private static Map runDirectionMap = null;
0330:
0331:            public static Map getRunDirectionMap() {
0332:                if (runDirectionMap == null) {
0333:                    runDirectionMap = new HashMap(4);
0334:                    runDirectionMap.put(RUN_DIRECTION_LTR, new Byte(
0335:                            JRPrintText.RUN_DIRECTION_LTR));
0336:                    runDirectionMap.put(RUN_DIRECTION_RTL, new Byte(
0337:                            JRPrintText.RUN_DIRECTION_RTL));
0338:                    runDirectionMap.put(
0339:                            new Byte(JRPrintText.RUN_DIRECTION_LTR),
0340:                            RUN_DIRECTION_LTR);
0341:                    runDirectionMap.put(
0342:                            new Byte(JRPrintText.RUN_DIRECTION_RTL),
0343:                            RUN_DIRECTION_RTL);
0344:                }
0345:
0346:                return runDirectionMap;
0347:            }
0348:
0349:            /**
0350:             *
0351:             */
0352:            private static final String LINE_SPACING_SINGLE = "Single";
0353:            private static final String LINE_SPACING_1_1_2 = "1_1_2";
0354:            private static final String LINE_SPACING_DOUBLE = "Double";
0355:
0356:            private static Map lineSpacingMap = null;
0357:
0358:            public static Map getLineSpacingMap() {
0359:                if (lineSpacingMap == null) {
0360:                    lineSpacingMap = new HashMap(6);
0361:                    lineSpacingMap.put(LINE_SPACING_SINGLE, new Byte(
0362:                            JRTextElement.LINE_SPACING_SINGLE));
0363:                    lineSpacingMap.put(LINE_SPACING_1_1_2, new Byte(
0364:                            JRTextElement.LINE_SPACING_1_1_2));
0365:                    lineSpacingMap.put(LINE_SPACING_DOUBLE, new Byte(
0366:                            JRTextElement.LINE_SPACING_DOUBLE));
0367:                    lineSpacingMap.put(new Byte(
0368:                            JRTextElement.LINE_SPACING_SINGLE),
0369:                            LINE_SPACING_SINGLE);
0370:                    lineSpacingMap.put(new Byte(
0371:                            JRTextElement.LINE_SPACING_1_1_2),
0372:                            LINE_SPACING_1_1_2);
0373:                    lineSpacingMap.put(new Byte(
0374:                            JRTextElement.LINE_SPACING_DOUBLE),
0375:                            LINE_SPACING_DOUBLE);
0376:                }
0377:
0378:                return lineSpacingMap;
0379:            }
0380:
0381:            /**
0382:             *
0383:             */
0384:            private static final String DIRECTION_TOP_DOWN = "TopDown";
0385:            private static final String DIRECTION_BOTTOM_UP = "BottomUp";
0386:
0387:            private static Map directionMap = null;
0388:
0389:            public static Map getDirectionMap() {
0390:                if (directionMap == null) {
0391:                    directionMap = new HashMap(4);
0392:                    directionMap.put(DIRECTION_TOP_DOWN, new Byte(
0393:                            JRLine.DIRECTION_TOP_DOWN));
0394:                    directionMap.put(DIRECTION_BOTTOM_UP, new Byte(
0395:                            JRLine.DIRECTION_BOTTOM_UP));
0396:                    directionMap.put(new Byte(JRLine.DIRECTION_TOP_DOWN),
0397:                            DIRECTION_TOP_DOWN);
0398:                    directionMap.put(new Byte(JRLine.DIRECTION_BOTTOM_UP),
0399:                            DIRECTION_BOTTOM_UP);
0400:                }
0401:
0402:                return directionMap;
0403:            }
0404:
0405:            /**
0406:             *
0407:             */
0408:            private static final String SCALE_IMAGE_CLIP = "Clip";
0409:            private static final String SCALE_IMAGE_FILL_FRAME = "FillFrame";
0410:            private static final String SCALE_IMAGE_RETAIN_SHAPE = "RetainShape";
0411:
0412:            private static Map scaleImageMap = null;
0413:
0414:            public static Map getScaleImageMap() {
0415:                if (scaleImageMap == null) {
0416:                    scaleImageMap = new HashMap(6);
0417:                    scaleImageMap.put(SCALE_IMAGE_CLIP, new Byte(
0418:                            JRImage.SCALE_IMAGE_CLIP));
0419:                    scaleImageMap.put(SCALE_IMAGE_FILL_FRAME, new Byte(
0420:                            JRImage.SCALE_IMAGE_FILL_FRAME));
0421:                    scaleImageMap.put(SCALE_IMAGE_RETAIN_SHAPE, new Byte(
0422:                            JRImage.SCALE_IMAGE_RETAIN_SHAPE));
0423:                    scaleImageMap.put(new Byte(JRImage.SCALE_IMAGE_CLIP),
0424:                            SCALE_IMAGE_CLIP);
0425:                    scaleImageMap.put(new Byte(JRImage.SCALE_IMAGE_FILL_FRAME),
0426:                            SCALE_IMAGE_FILL_FRAME);
0427:                    scaleImageMap.put(
0428:                            new Byte(JRImage.SCALE_IMAGE_RETAIN_SHAPE),
0429:                            SCALE_IMAGE_RETAIN_SHAPE);
0430:                }
0431:
0432:                return scaleImageMap;
0433:            }
0434:
0435:            /**
0436:             *
0437:             */
0438:            private static final String ON_ERROR_TYPE_ERROR = "Error";
0439:            private static final String ON_ERROR_TYPE_BLANK = "Blank";
0440:            private static final String ON_ERROR_TYPE_ICON = "Icon";
0441:
0442:            private static Map onErrorTypeMap = null;
0443:
0444:            public static Map getOnErrorTypeMap() {
0445:                if (onErrorTypeMap == null) {
0446:                    onErrorTypeMap = new HashMap(6);
0447:                    onErrorTypeMap.put(ON_ERROR_TYPE_ERROR, new Byte(
0448:                            JRImage.ON_ERROR_TYPE_ERROR));
0449:                    onErrorTypeMap.put(ON_ERROR_TYPE_BLANK, new Byte(
0450:                            JRImage.ON_ERROR_TYPE_BLANK));
0451:                    onErrorTypeMap.put(ON_ERROR_TYPE_ICON, new Byte(
0452:                            JRImage.ON_ERROR_TYPE_ICON));
0453:                    onErrorTypeMap.put(new Byte(JRImage.ON_ERROR_TYPE_ERROR),
0454:                            ON_ERROR_TYPE_ERROR);
0455:                    onErrorTypeMap.put(new Byte(JRImage.ON_ERROR_TYPE_BLANK),
0456:                            ON_ERROR_TYPE_BLANK);
0457:                    onErrorTypeMap.put(new Byte(JRImage.ON_ERROR_TYPE_ICON),
0458:                            ON_ERROR_TYPE_ICON);
0459:                }
0460:
0461:                return onErrorTypeMap;
0462:            }
0463:
0464:            /**
0465:             *
0466:             */
0467:            private static final String STRETCH_TYPE_NO_STRETCH = "NoStretch";
0468:            private static final String STRETCH_TYPE_RELATIVE_TO_TALLEST_OBJECT = "RelativeToTallestObject";
0469:            private static final String STRETCH_TYPE_RELATIVE_TO_BAND_HEIGHT = "RelativeToBandHeight";
0470:
0471:            private static Map stretchTypeMap = null;
0472:
0473:            public static Map getStretchTypeMap() {
0474:                if (stretchTypeMap == null) {
0475:                    stretchTypeMap = new HashMap(6);
0476:                    stretchTypeMap.put(STRETCH_TYPE_NO_STRETCH, new Byte(
0477:                            JRElement.STRETCH_TYPE_NO_STRETCH));
0478:                    stretchTypeMap
0479:                            .put(
0480:                                    STRETCH_TYPE_RELATIVE_TO_TALLEST_OBJECT,
0481:                                    new Byte(
0482:                                            JRElement.STRETCH_TYPE_RELATIVE_TO_TALLEST_OBJECT));
0483:                    stretchTypeMap
0484:                            .put(
0485:                                    STRETCH_TYPE_RELATIVE_TO_BAND_HEIGHT,
0486:                                    new Byte(
0487:                                            JRElement.STRETCH_TYPE_RELATIVE_TO_BAND_HEIGHT));
0488:                    stretchTypeMap.put(new Byte(
0489:                            JRElement.STRETCH_TYPE_NO_STRETCH),
0490:                            STRETCH_TYPE_NO_STRETCH);
0491:                    stretchTypeMap.put(new Byte(
0492:                            JRElement.STRETCH_TYPE_RELATIVE_TO_TALLEST_OBJECT),
0493:                            STRETCH_TYPE_RELATIVE_TO_TALLEST_OBJECT);
0494:                    stretchTypeMap.put(new Byte(
0495:                            JRElement.STRETCH_TYPE_RELATIVE_TO_BAND_HEIGHT),
0496:                            STRETCH_TYPE_RELATIVE_TO_BAND_HEIGHT);
0497:                }
0498:
0499:                return stretchTypeMap;
0500:            }
0501:
0502:            /**
0503:             *
0504:             */
0505:            private static final String PEN_NONE = "None";
0506:            private static final String PEN_THIN = "Thin";
0507:            private static final String PEN_1_POINT = "1Point";
0508:            private static final String PEN_2_POINT = "2Point";
0509:            private static final String PEN_4_POINT = "4Point";
0510:            private static final String PEN_DOTTED = "Dotted";
0511:
0512:            private static Map penMap = null;
0513:
0514:            public static Map getPenMap() {
0515:                if (penMap == null) {
0516:                    penMap = new HashMap(10);
0517:                    penMap.put(PEN_NONE, new Byte(JRGraphicElement.PEN_NONE));
0518:                    penMap.put(PEN_THIN, new Byte(JRGraphicElement.PEN_THIN));
0519:                    penMap.put(PEN_1_POINT, new Byte(
0520:                            JRGraphicElement.PEN_1_POINT));
0521:                    penMap.put(PEN_2_POINT, new Byte(
0522:                            JRGraphicElement.PEN_2_POINT));
0523:                    penMap.put(PEN_4_POINT, new Byte(
0524:                            JRGraphicElement.PEN_4_POINT));
0525:                    penMap.put(PEN_DOTTED,
0526:                            new Byte(JRGraphicElement.PEN_DOTTED));
0527:                    penMap.put(new Byte(JRGraphicElement.PEN_NONE), PEN_NONE);
0528:                    penMap.put(new Byte(JRGraphicElement.PEN_THIN), PEN_THIN);
0529:                    penMap.put(new Byte(JRGraphicElement.PEN_1_POINT),
0530:                            PEN_1_POINT);
0531:                    penMap.put(new Byte(JRGraphicElement.PEN_2_POINT),
0532:                            PEN_2_POINT);
0533:                    penMap.put(new Byte(JRGraphicElement.PEN_4_POINT),
0534:                            PEN_4_POINT);
0535:                    penMap.put(new Byte(JRGraphicElement.PEN_DOTTED),
0536:                            PEN_DOTTED);
0537:                }
0538:
0539:                return penMap;
0540:            }
0541:
0542:            /**
0543:             *
0544:             */
0545:            private static final String FILL_SOLID = "Solid";
0546:
0547:            private static Map fillMap = null;
0548:
0549:            public static Map getFillMap() {
0550:                if (fillMap == null) {
0551:                    fillMap = new HashMap(2);
0552:                    fillMap.put(FILL_SOLID, new Byte(
0553:                            JRGraphicElement.FILL_SOLID));
0554:                    fillMap.put(new Byte(JRGraphicElement.FILL_SOLID),
0555:                            FILL_SOLID);
0556:                }
0557:
0558:                return fillMap;
0559:            }
0560:
0561:            /**
0562:             *
0563:             */
0564:            private static final String RESET_TYPE_NONE = "None";
0565:            private static final String RESET_TYPE_REPORT = "Report";
0566:            private static final String RESET_TYPE_PAGE = "Page";
0567:            private static final String RESET_TYPE_COLUMN = "Column";
0568:            private static final String RESET_TYPE_GROUP = "Group";
0569:
0570:            private static Map resetTypeMap = null;
0571:
0572:            public static Map getResetTypeMap() {
0573:                if (resetTypeMap == null) {
0574:                    resetTypeMap = new HashMap(10);
0575:                    resetTypeMap.put(RESET_TYPE_NONE, new Byte(
0576:                            JRVariable.RESET_TYPE_NONE));
0577:                    resetTypeMap.put(RESET_TYPE_REPORT, new Byte(
0578:                            JRVariable.RESET_TYPE_REPORT));
0579:                    resetTypeMap.put(RESET_TYPE_PAGE, new Byte(
0580:                            JRVariable.RESET_TYPE_PAGE));
0581:                    resetTypeMap.put(RESET_TYPE_COLUMN, new Byte(
0582:                            JRVariable.RESET_TYPE_COLUMN));
0583:                    resetTypeMap.put(RESET_TYPE_GROUP, new Byte(
0584:                            JRVariable.RESET_TYPE_GROUP));
0585:                    resetTypeMap.put(new Byte(JRVariable.RESET_TYPE_NONE),
0586:                            RESET_TYPE_NONE);
0587:                    resetTypeMap.put(new Byte(JRVariable.RESET_TYPE_REPORT),
0588:                            RESET_TYPE_REPORT);
0589:                    resetTypeMap.put(new Byte(JRVariable.RESET_TYPE_PAGE),
0590:                            RESET_TYPE_PAGE);
0591:                    resetTypeMap.put(new Byte(JRVariable.RESET_TYPE_COLUMN),
0592:                            RESET_TYPE_COLUMN);
0593:                    resetTypeMap.put(new Byte(JRVariable.RESET_TYPE_GROUP),
0594:                            RESET_TYPE_GROUP);
0595:                }
0596:
0597:                return resetTypeMap;
0598:            }
0599:
0600:            /**
0601:             *
0602:             */
0603:            private static final String CALCULATION_NOTHING = "Nothing";
0604:            private static final String CALCULATION_COUNT = "Count";
0605:            private static final String CALCULATION_SUM = "Sum";
0606:            private static final String CALCULATION_AVERAGE = "Average";
0607:            private static final String CALCULATION_LOWEST = "Lowest";
0608:            private static final String CALCULATION_HIGHEST = "Highest";
0609:            private static final String CALCULATION_STANDARD_DEVIATION = "StandardDeviation";
0610:            private static final String CALCULATION_VARIANCE = "Variance";
0611:            private static final String CALCULATION_SYSTEM = "System";
0612:            private static final String CALCULATION_FIRST = "First";
0613:            private static final String CALCULATION_DISTINCT_COUNT = "DistinctCount";
0614:
0615:            private static Map calculationMap = null;
0616:
0617:            public static Map getCalculationMap() {
0618:                if (calculationMap == null) {
0619:                    calculationMap = new HashMap(18);
0620:                    calculationMap.put(CALCULATION_NOTHING, new Byte(
0621:                            JRVariable.CALCULATION_NOTHING));
0622:                    calculationMap.put(CALCULATION_COUNT, new Byte(
0623:                            JRVariable.CALCULATION_COUNT));
0624:                    calculationMap.put(CALCULATION_SUM, new Byte(
0625:                            JRVariable.CALCULATION_SUM));
0626:                    calculationMap.put(CALCULATION_AVERAGE, new Byte(
0627:                            JRVariable.CALCULATION_AVERAGE));
0628:                    calculationMap.put(CALCULATION_LOWEST, new Byte(
0629:                            JRVariable.CALCULATION_LOWEST));
0630:                    calculationMap.put(CALCULATION_HIGHEST, new Byte(
0631:                            JRVariable.CALCULATION_HIGHEST));
0632:                    calculationMap
0633:                            .put(CALCULATION_STANDARD_DEVIATION, new Byte(
0634:                                    JRVariable.CALCULATION_STANDARD_DEVIATION));
0635:                    calculationMap.put(CALCULATION_VARIANCE, new Byte(
0636:                            JRVariable.CALCULATION_VARIANCE));
0637:                    calculationMap.put(CALCULATION_SYSTEM, new Byte(
0638:                            JRVariable.CALCULATION_SYSTEM));
0639:                    calculationMap.put(CALCULATION_FIRST, new Byte(
0640:                            JRVariable.CALCULATION_FIRST));
0641:                    calculationMap.put(CALCULATION_DISTINCT_COUNT, new Byte(
0642:                            JRVariable.CALCULATION_DISTINCT_COUNT));
0643:                    calculationMap.put(
0644:                            new Byte(JRVariable.CALCULATION_NOTHING),
0645:                            CALCULATION_NOTHING);
0646:                    calculationMap.put(new Byte(JRVariable.CALCULATION_COUNT),
0647:                            CALCULATION_COUNT);
0648:                    calculationMap.put(new Byte(JRVariable.CALCULATION_SUM),
0649:                            CALCULATION_SUM);
0650:                    calculationMap.put(
0651:                            new Byte(JRVariable.CALCULATION_AVERAGE),
0652:                            CALCULATION_AVERAGE);
0653:                    calculationMap.put(new Byte(JRVariable.CALCULATION_LOWEST),
0654:                            CALCULATION_LOWEST);
0655:                    calculationMap.put(
0656:                            new Byte(JRVariable.CALCULATION_HIGHEST),
0657:                            CALCULATION_HIGHEST);
0658:                    calculationMap.put(new Byte(
0659:                            JRVariable.CALCULATION_STANDARD_DEVIATION),
0660:                            CALCULATION_STANDARD_DEVIATION);
0661:                    calculationMap.put(
0662:                            new Byte(JRVariable.CALCULATION_VARIANCE),
0663:                            CALCULATION_VARIANCE);
0664:                    calculationMap.put(new Byte(JRVariable.CALCULATION_SYSTEM),
0665:                            CALCULATION_SYSTEM);
0666:                    calculationMap.put(new Byte(JRVariable.CALCULATION_FIRST),
0667:                            CALCULATION_FIRST);
0668:                    calculationMap.put(new Byte(
0669:                            JRVariable.CALCULATION_DISTINCT_COUNT),
0670:                            CALCULATION_DISTINCT_COUNT);
0671:                }
0672:
0673:                return calculationMap;
0674:            }
0675:
0676:            /**
0677:             *
0678:             */
0679:            private static final String PRINT_ORDER_VERTICAL = "Vertical";
0680:            private static final String PRINT_ORDER_HORIZONTAL = "Horizontal";
0681:
0682:            private static Map printOrderMap = null;
0683:
0684:            public static Map getPrintOrderMap() {
0685:                if (printOrderMap == null) {
0686:                    printOrderMap = new HashMap(4);
0687:                    printOrderMap.put(PRINT_ORDER_VERTICAL, new Byte(
0688:                            JRReport.PRINT_ORDER_VERTICAL));
0689:                    printOrderMap.put(PRINT_ORDER_HORIZONTAL, new Byte(
0690:                            JRReport.PRINT_ORDER_HORIZONTAL));
0691:                    printOrderMap.put(new Byte(JRReport.PRINT_ORDER_VERTICAL),
0692:                            PRINT_ORDER_VERTICAL);
0693:                    printOrderMap.put(
0694:                            new Byte(JRReport.PRINT_ORDER_HORIZONTAL),
0695:                            PRINT_ORDER_HORIZONTAL);
0696:                }
0697:
0698:                return printOrderMap;
0699:            }
0700:
0701:            /**
0702:             *
0703:             */
0704:            private static final String ORIENTATION_PORTRAIT = "Portrait";
0705:            private static final String ORIENTATION_LANDSCAPE = "Landscape";
0706:
0707:            private static Map orientationMap = null;
0708:
0709:            public static Map getOrientationMap() {
0710:                if (orientationMap == null) {
0711:                    orientationMap = new HashMap(4);
0712:                    orientationMap.put(ORIENTATION_PORTRAIT, new Byte(
0713:                            JRReport.ORIENTATION_PORTRAIT));
0714:                    orientationMap.put(ORIENTATION_LANDSCAPE, new Byte(
0715:                            JRReport.ORIENTATION_LANDSCAPE));
0716:                    orientationMap.put(new Byte(JRReport.ORIENTATION_PORTRAIT),
0717:                            ORIENTATION_PORTRAIT);
0718:                    orientationMap.put(
0719:                            new Byte(JRReport.ORIENTATION_LANDSCAPE),
0720:                            ORIENTATION_LANDSCAPE);
0721:                }
0722:
0723:                return orientationMap;
0724:            }
0725:
0726:            /**
0727:             *
0728:             */
0729:            private static final String WHEN_NO_DATA_TYPE_NO_PAGES = "NoPages";
0730:            private static final String WHEN_NO_DATA_TYPE_BLANK_PAGE = "BlankPage";
0731:            private static final String WHEN_NO_DATA_TYPE_ALL_SECTIONS_NO_DETAIL = "AllSectionsNoDetail";
0732:            private static final String WHEN_NO_DATA_TYPE_NO_DATA_SECTION = "NoDataSection";
0733:
0734:            private static Map whenNoDataTypeMap = null;
0735:
0736:            public static Map getWhenNoDataTypeMap() {
0737:                if (whenNoDataTypeMap == null) {
0738:                    whenNoDataTypeMap = new HashMap(6);
0739:                    whenNoDataTypeMap.put(WHEN_NO_DATA_TYPE_NO_PAGES, new Byte(
0740:                            JRReport.WHEN_NO_DATA_TYPE_NO_PAGES));
0741:                    whenNoDataTypeMap.put(WHEN_NO_DATA_TYPE_BLANK_PAGE,
0742:                            new Byte(JRReport.WHEN_NO_DATA_TYPE_BLANK_PAGE));
0743:                    whenNoDataTypeMap
0744:                            .put(
0745:                                    WHEN_NO_DATA_TYPE_ALL_SECTIONS_NO_DETAIL,
0746:                                    new Byte(
0747:                                            JRReport.WHEN_NO_DATA_TYPE_ALL_SECTIONS_NO_DETAIL));
0748:                    whenNoDataTypeMap
0749:                            .put(WHEN_NO_DATA_TYPE_NO_DATA_SECTION, new Byte(
0750:                                    JRReport.WHEN_NO_DATA_TYPE_NO_DATA_SECTION));
0751:                    whenNoDataTypeMap.put(new Byte(
0752:                            JRReport.WHEN_NO_DATA_TYPE_NO_PAGES),
0753:                            WHEN_NO_DATA_TYPE_NO_PAGES);
0754:                    whenNoDataTypeMap.put(new Byte(
0755:                            JRReport.WHEN_NO_DATA_TYPE_BLANK_PAGE),
0756:                            WHEN_NO_DATA_TYPE_BLANK_PAGE);
0757:                    whenNoDataTypeMap.put(new Byte(
0758:                            JRReport.WHEN_NO_DATA_TYPE_ALL_SECTIONS_NO_DETAIL),
0759:                            WHEN_NO_DATA_TYPE_ALL_SECTIONS_NO_DETAIL);
0760:                    whenNoDataTypeMap.put(new Byte(
0761:                            JRReport.WHEN_NO_DATA_TYPE_NO_DATA_SECTION),
0762:                            WHEN_NO_DATA_TYPE_NO_DATA_SECTION);
0763:                }
0764:
0765:                return whenNoDataTypeMap;
0766:            }
0767:
0768:            /**
0769:             *
0770:             */
0771:            private static final String EVALUATION_TIME_NOW = "Now";
0772:            private static final String EVALUATION_TIME_REPORT = "Report";
0773:            private static final String EVALUATION_TIME_PAGE = "Page";
0774:            private static final String EVALUATION_TIME_COLUMN = "Column";
0775:            private static final String EVALUATION_TIME_GROUP = "Group";
0776:            private static final String EVALUATION_TIME_BAND = "Band";
0777:            private static final String EVALUATION_TIME_AUTO = "Auto";
0778:
0779:            private static Map evaluationTimeMap = null;
0780:
0781:            public static Map getEvaluationTimeMap() {
0782:                if (evaluationTimeMap == null) {
0783:                    evaluationTimeMap = new HashMap(10);
0784:                    evaluationTimeMap.put(EVALUATION_TIME_NOW, new Byte(
0785:                            JRExpression.EVALUATION_TIME_NOW));
0786:                    evaluationTimeMap.put(EVALUATION_TIME_REPORT, new Byte(
0787:                            JRExpression.EVALUATION_TIME_REPORT));
0788:                    evaluationTimeMap.put(EVALUATION_TIME_PAGE, new Byte(
0789:                            JRExpression.EVALUATION_TIME_PAGE));
0790:                    evaluationTimeMap.put(EVALUATION_TIME_COLUMN, new Byte(
0791:                            JRExpression.EVALUATION_TIME_COLUMN));
0792:                    evaluationTimeMap.put(EVALUATION_TIME_GROUP, new Byte(
0793:                            JRExpression.EVALUATION_TIME_GROUP));
0794:                    evaluationTimeMap.put(EVALUATION_TIME_BAND, new Byte(
0795:                            JRExpression.EVALUATION_TIME_BAND));
0796:                    evaluationTimeMap.put(EVALUATION_TIME_AUTO, new Byte(
0797:                            JRExpression.EVALUATION_TIME_AUTO));
0798:                    evaluationTimeMap.put(new Byte(
0799:                            JRExpression.EVALUATION_TIME_NOW),
0800:                            EVALUATION_TIME_NOW);
0801:                    evaluationTimeMap.put(new Byte(
0802:                            JRExpression.EVALUATION_TIME_REPORT),
0803:                            EVALUATION_TIME_REPORT);
0804:                    evaluationTimeMap.put(new Byte(
0805:                            JRExpression.EVALUATION_TIME_PAGE),
0806:                            EVALUATION_TIME_PAGE);
0807:                    evaluationTimeMap.put(new Byte(
0808:                            JRExpression.EVALUATION_TIME_COLUMN),
0809:                            EVALUATION_TIME_COLUMN);
0810:                    evaluationTimeMap.put(new Byte(
0811:                            JRExpression.EVALUATION_TIME_GROUP),
0812:                            EVALUATION_TIME_GROUP);
0813:                    evaluationTimeMap.put(new Byte(
0814:                            JRExpression.EVALUATION_TIME_BAND),
0815:                            EVALUATION_TIME_BAND);
0816:                    evaluationTimeMap.put(new Byte(
0817:                            JRExpression.EVALUATION_TIME_AUTO),
0818:                            EVALUATION_TIME_AUTO);
0819:                }
0820:
0821:                return evaluationTimeMap;
0822:            }
0823:
0824:            /**
0825:             *
0826:             */
0827:            private static final String HYPERLINK_TYPE_NONE = "None";
0828:            private static final String HYPERLINK_TYPE_REFERENCE = "Reference";
0829:            private static final String HYPERLINK_TYPE_LOCAL_ANCHOR = "LocalAnchor";
0830:            private static final String HYPERLINK_TYPE_LOCAL_PAGE = "LocalPage";
0831:            private static final String HYPERLINK_TYPE_REMOTE_ANCHOR = "RemoteAnchor";
0832:            private static final String HYPERLINK_TYPE_REMOTE_PAGE = "RemotePage";
0833:
0834:            private static Map hyperlinkTypeMap = null;
0835:
0836:            /**
0837:             * @deprecated {@link JRHyperlinkHelper JRHyperlinkHelper} should be used instead.
0838:             */
0839:            public static Map getHyperlinkTypeMap() {
0840:                if (hyperlinkTypeMap == null) {
0841:                    hyperlinkTypeMap = new HashMap(12);
0842:                    hyperlinkTypeMap.put(HYPERLINK_TYPE_NONE, new Byte(
0843:                            JRHyperlink.HYPERLINK_TYPE_NONE));
0844:                    hyperlinkTypeMap.put(HYPERLINK_TYPE_REFERENCE, new Byte(
0845:                            JRHyperlink.HYPERLINK_TYPE_REFERENCE));
0846:                    hyperlinkTypeMap.put(HYPERLINK_TYPE_LOCAL_ANCHOR, new Byte(
0847:                            JRHyperlink.HYPERLINK_TYPE_LOCAL_ANCHOR));
0848:                    hyperlinkTypeMap.put(HYPERLINK_TYPE_LOCAL_PAGE, new Byte(
0849:                            JRHyperlink.HYPERLINK_TYPE_LOCAL_PAGE));
0850:                    hyperlinkTypeMap.put(HYPERLINK_TYPE_REMOTE_ANCHOR,
0851:                            new Byte(JRHyperlink.HYPERLINK_TYPE_REMOTE_ANCHOR));
0852:                    hyperlinkTypeMap.put(HYPERLINK_TYPE_REMOTE_PAGE, new Byte(
0853:                            JRHyperlink.HYPERLINK_TYPE_REMOTE_PAGE));
0854:                    hyperlinkTypeMap.put(new Byte(
0855:                            JRHyperlink.HYPERLINK_TYPE_NONE),
0856:                            HYPERLINK_TYPE_NONE);
0857:                    hyperlinkTypeMap.put(new Byte(
0858:                            JRHyperlink.HYPERLINK_TYPE_REFERENCE),
0859:                            HYPERLINK_TYPE_REFERENCE);
0860:                    hyperlinkTypeMap.put(new Byte(
0861:                            JRHyperlink.HYPERLINK_TYPE_LOCAL_ANCHOR),
0862:                            HYPERLINK_TYPE_LOCAL_ANCHOR);
0863:                    hyperlinkTypeMap.put(new Byte(
0864:                            JRHyperlink.HYPERLINK_TYPE_LOCAL_PAGE),
0865:                            HYPERLINK_TYPE_LOCAL_PAGE);
0866:                    hyperlinkTypeMap.put(new Byte(
0867:                            JRHyperlink.HYPERLINK_TYPE_REMOTE_ANCHOR),
0868:                            HYPERLINK_TYPE_REMOTE_ANCHOR);
0869:                    hyperlinkTypeMap.put(new Byte(
0870:                            JRHyperlink.HYPERLINK_TYPE_REMOTE_PAGE),
0871:                            HYPERLINK_TYPE_REMOTE_PAGE);
0872:                }
0873:
0874:                return hyperlinkTypeMap;
0875:            }
0876:
0877:            /**
0878:             *
0879:             */
0880:            private static final String HYPERLINK_TARGET_SELF = "Self";
0881:            private static final String HYPERLINK_TARGET_BLANK = "Blank";
0882:
0883:            private static Map hyperlinkTargetMap = null;
0884:
0885:            public static Map getHyperlinkTargetMap() {
0886:                if (hyperlinkTargetMap == null) {
0887:                    hyperlinkTargetMap = new HashMap(4);
0888:                    hyperlinkTargetMap.put(HYPERLINK_TARGET_SELF, new Byte(
0889:                            JRHyperlink.HYPERLINK_TARGET_SELF));
0890:                    hyperlinkTargetMap.put(HYPERLINK_TARGET_BLANK, new Byte(
0891:                            JRHyperlink.HYPERLINK_TARGET_BLANK));
0892:                    hyperlinkTargetMap.put(new Byte(
0893:                            JRHyperlink.HYPERLINK_TARGET_SELF),
0894:                            HYPERLINK_TARGET_SELF);
0895:                    hyperlinkTargetMap.put(new Byte(
0896:                            JRHyperlink.HYPERLINK_TARGET_BLANK),
0897:                            HYPERLINK_TARGET_BLANK);
0898:                }
0899:
0900:                return hyperlinkTargetMap;
0901:            }
0902:
0903:            /**
0904:             *
0905:             */
0906:            public static final String TITLE_POSITION_TOP = "Top";
0907:            public static final String TITLE_POSITION_BOTTOM = "Bottom";
0908:            public static final String TITLE_POSITION_LEFT = "Left";
0909:            public static final String TITLE_POSITION_RIGHT = "Right";
0910:
0911:            public static Map chartTitlePositionMap = null;
0912:
0913:            public static Map getChartTitlePositionMap() {
0914:                if (chartTitlePositionMap == null) {
0915:                    chartTitlePositionMap = new HashMap(4);
0916:                    chartTitlePositionMap.put(TITLE_POSITION_TOP, new Byte(
0917:                            JRChart.TITLE_POSITION_TOP));
0918:                    chartTitlePositionMap.put(TITLE_POSITION_BOTTOM, new Byte(
0919:                            JRChart.TITLE_POSITION_BOTTOM));
0920:                    chartTitlePositionMap.put(TITLE_POSITION_LEFT, new Byte(
0921:                            JRChart.TITLE_POSITION_LEFT));
0922:                    chartTitlePositionMap.put(TITLE_POSITION_RIGHT, new Byte(
0923:                            JRChart.TITLE_POSITION_RIGHT));
0924:                    chartTitlePositionMap.put(new Byte(
0925:                            JRChart.TITLE_POSITION_TOP), TITLE_POSITION_TOP);
0926:                    chartTitlePositionMap.put(new Byte(
0927:                            JRChart.TITLE_POSITION_BOTTOM),
0928:                            TITLE_POSITION_BOTTOM);
0929:                    chartTitlePositionMap.put(new Byte(
0930:                            JRChart.TITLE_POSITION_LEFT), TITLE_POSITION_LEFT);
0931:                    chartTitlePositionMap
0932:                            .put(new Byte(JRChart.TITLE_POSITION_RIGHT),
0933:                                    TITLE_POSITION_RIGHT);
0934:                }
0935:
0936:                return chartTitlePositionMap;
0937:            }
0938:
0939:            /**
0940:             *
0941:             */
0942:            private static final String ORIENTATION_HORIZONTAL = "Horizontal";
0943:            private static final String ORIENTATION_VERTICAL = "Vertical";
0944:
0945:            private static Map plotOrientationMap = null;
0946:
0947:            public static Map getPlotOrientationMap() {
0948:                if (plotOrientationMap == null) {
0949:                    plotOrientationMap = new HashMap(4);
0950:                    plotOrientationMap.put(ORIENTATION_HORIZONTAL,
0951:                            PlotOrientation.HORIZONTAL);
0952:                    plotOrientationMap.put(ORIENTATION_VERTICAL,
0953:                            PlotOrientation.VERTICAL);
0954:                    plotOrientationMap.put(PlotOrientation.HORIZONTAL,
0955:                            ORIENTATION_HORIZONTAL);
0956:                    plotOrientationMap.put(PlotOrientation.VERTICAL,
0957:                            ORIENTATION_VERTICAL);
0958:                }
0959:
0960:                return plotOrientationMap;
0961:            }
0962:
0963:            /**
0964:             *
0965:             */
0966:            private static final String SORT_ORDER_ASCENDING = "Ascending";
0967:            private static final String SORT_ORDER_DESCENDING = "Descending";
0968:
0969:            private static Map sortOrderMap = null;
0970:
0971:            public static Map getSortOrderMap() {
0972:                if (sortOrderMap == null) {
0973:                    sortOrderMap = new HashMap(4);
0974:                    sortOrderMap.put(SORT_ORDER_ASCENDING, new Byte(
0975:                            JRSortField.SORT_ORDER_ASCENDING));
0976:                    sortOrderMap.put(SORT_ORDER_DESCENDING, new Byte(
0977:                            JRSortField.SORT_ORDER_DESCENDING));
0978:                    sortOrderMap.put(
0979:                            new Byte(JRSortField.SORT_ORDER_ASCENDING),
0980:                            SORT_ORDER_ASCENDING);
0981:                    sortOrderMap.put(
0982:                            new Byte(JRSortField.SORT_ORDER_DESCENDING),
0983:                            SORT_ORDER_DESCENDING);
0984:                }
0985:
0986:                return sortOrderMap;
0987:            }
0988:
0989:            private static final String SCALE_ON_BOTH_AXES = "BothAxes";
0990:            private static final String SCALE_ON_DOMAIN_AXIS = "DomainAxis";
0991:            private static final String SCALE_ON_RANGE_AXIS = "RangeAxis";
0992:
0993:            private static Map scaleTypeMap = null;
0994:
0995:            public static Map getScaleTypeMap() {
0996:                if (scaleTypeMap == null) {
0997:                    scaleTypeMap = new HashMap(6);
0998:                    scaleTypeMap.put(SCALE_ON_BOTH_AXES, new Integer(
0999:                            XYBubbleRenderer.SCALE_ON_BOTH_AXES));
1000:                    scaleTypeMap.put(SCALE_ON_DOMAIN_AXIS, new Integer(
1001:                            XYBubbleRenderer.SCALE_ON_DOMAIN_AXIS));
1002:                    scaleTypeMap.put(SCALE_ON_RANGE_AXIS, new Integer(
1003:                            XYBubbleRenderer.SCALE_ON_RANGE_AXIS));
1004:                    scaleTypeMap.put(new Integer(
1005:                            XYBubbleRenderer.SCALE_ON_BOTH_AXES),
1006:                            SCALE_ON_BOTH_AXES);
1007:                    scaleTypeMap.put(new Integer(
1008:                            XYBubbleRenderer.SCALE_ON_DOMAIN_AXIS),
1009:                            SCALE_ON_DOMAIN_AXIS);
1010:                    scaleTypeMap.put(new Integer(
1011:                            XYBubbleRenderer.SCALE_ON_RANGE_AXIS),
1012:                            SCALE_ON_RANGE_AXIS);
1013:                }
1014:
1015:                return scaleTypeMap;
1016:            }
1017:
1018:            private static final String TIME_PERIOD_YEAR = "Year";
1019:            private static final String TIME_PERIOD_QUARTER = "Quarter";
1020:            private static final String TIME_PERIOD_MONTH = "Month";
1021:            private static final String TIME_PERIOD_WEEK = "Week";
1022:            private static final String TIME_PERIOD_DAY = "Day";
1023:            private static final String TIME_PERIOD_HOUR = "Hour";
1024:            private static final String TIME_PERIOD_MINUTE = "Minute";
1025:            private static final String TIME_PERIOD_SECOND = "Second";
1026:            private static final String TIME_PERIOD_MILISECOND = "Milisecond";
1027:
1028:            public static Class getTimePeriod(String timePeriod) {
1029:                if (timePeriod.equals(TIME_PERIOD_YEAR)) {
1030:                    return Year.class;
1031:                } else if (timePeriod.equals(TIME_PERIOD_QUARTER)) {
1032:                    return Quarter.class;
1033:                } else if (timePeriod.equals(TIME_PERIOD_MONTH)) {
1034:                    return Month.class;
1035:                } else if (timePeriod.equals(TIME_PERIOD_WEEK)) {
1036:                    return Week.class;
1037:                } else if (timePeriod.equals(TIME_PERIOD_DAY)) {
1038:                    return Day.class;
1039:                } else if (timePeriod.equals(TIME_PERIOD_HOUR)) {
1040:                    return Hour.class;
1041:                } else if (timePeriod.equals(TIME_PERIOD_MINUTE)) {
1042:                    return Minute.class;
1043:                } else if (timePeriod.equals(TIME_PERIOD_SECOND)) {
1044:                    return Second.class;
1045:                } else {
1046:                    return Millisecond.class;
1047:                }
1048:
1049:            }
1050:
1051:            public static String getTimePeriodName(Class clazz) {
1052:                if (clazz.equals(Year.class)) {
1053:                    return TIME_PERIOD_YEAR;
1054:                } else if (clazz.equals(Quarter.class)) {
1055:                    return TIME_PERIOD_QUARTER;
1056:                } else if (clazz.equals(Month.class)) {
1057:                    return TIME_PERIOD_MONTH;
1058:                } else if (clazz.equals(Week.class)) {
1059:                    return TIME_PERIOD_WEEK;
1060:                } else if (clazz.equals(Day.class)) {
1061:                    return TIME_PERIOD_DAY;
1062:                } else if (clazz.equals(Hour.class)) {
1063:                    return TIME_PERIOD_HOUR;
1064:                } else if (clazz.equals(Minute.class)) {
1065:                    return TIME_PERIOD_MINUTE;
1066:                } else if (clazz.equals(Second.class)) {
1067:                    return TIME_PERIOD_SECOND;
1068:                } else {
1069:                    return TIME_PERIOD_MILISECOND;
1070:                }
1071:            }
1072:
1073:            /**
1074:             *
1075:             */
1076:            private static final String WHEN_RESOURCE_MISSING_TYPE_NULL = "Null";
1077:            private static final String WHEN_RESOURCE_MISSING_TYPE_EMPTY = "Empty";
1078:            private static final String WHEN_RESOURCE_MISSING_TYPE_KEY = "Key";
1079:            private static final String WHEN_RESOURCE_MISSING_TYPE_ERROR = "Error";
1080:
1081:            private static Map whenResourceMissingTypeMap = null;
1082:
1083:            public static Map getWhenResourceMissingTypeMap() {
1084:                if (whenResourceMissingTypeMap == null) {
1085:                    whenResourceMissingTypeMap = new HashMap();
1086:                    whenResourceMissingTypeMap.put(
1087:                            WHEN_RESOURCE_MISSING_TYPE_NULL, new Byte(
1088:                                    JRReport.WHEN_RESOURCE_MISSING_TYPE_NULL));
1089:                    whenResourceMissingTypeMap.put(
1090:                            WHEN_RESOURCE_MISSING_TYPE_EMPTY, new Byte(
1091:                                    JRReport.WHEN_RESOURCE_MISSING_TYPE_EMPTY));
1092:                    whenResourceMissingTypeMap.put(
1093:                            WHEN_RESOURCE_MISSING_TYPE_KEY, new Byte(
1094:                                    JRReport.WHEN_RESOURCE_MISSING_TYPE_KEY));
1095:                    whenResourceMissingTypeMap.put(
1096:                            WHEN_RESOURCE_MISSING_TYPE_ERROR, new Byte(
1097:                                    JRReport.WHEN_RESOURCE_MISSING_TYPE_ERROR));
1098:                    whenResourceMissingTypeMap.put(new Byte(
1099:                            JRReport.WHEN_RESOURCE_MISSING_TYPE_NULL),
1100:                            WHEN_RESOURCE_MISSING_TYPE_NULL);
1101:                    whenResourceMissingTypeMap.put(new Byte(
1102:                            JRReport.WHEN_RESOURCE_MISSING_TYPE_EMPTY),
1103:                            WHEN_RESOURCE_MISSING_TYPE_EMPTY);
1104:                    whenResourceMissingTypeMap.put(new Byte(
1105:                            JRReport.WHEN_RESOURCE_MISSING_TYPE_KEY),
1106:                            WHEN_RESOURCE_MISSING_TYPE_KEY);
1107:                    whenResourceMissingTypeMap.put(new Byte(
1108:                            JRReport.WHEN_RESOURCE_MISSING_TYPE_ERROR),
1109:                            WHEN_RESOURCE_MISSING_TYPE_ERROR);
1110:                }
1111:
1112:                return whenResourceMissingTypeMap;
1113:            }
1114:
1115:            /**
1116:             *
1117:             */
1118:            private static final String METER_SHAPE_CHORD = "chord";
1119:            private static final String METER_SHAPE_CIRCLE = "circle";
1120:            private static final String METER_SHAPE_PIE = "pie";
1121:
1122:            private static Map meterShapeMap = null;
1123:
1124:            public static Map getMeterShapeMap() {
1125:                if (meterShapeMap == null) {
1126:                    meterShapeMap = new HashMap();
1127:                    meterShapeMap.put(METER_SHAPE_CHORD, new Byte(
1128:                            JRMeterPlot.SHAPE_CHORD));
1129:                    meterShapeMap.put(METER_SHAPE_CIRCLE, new Byte(
1130:                            JRMeterPlot.SHAPE_CIRCLE));
1131:                    meterShapeMap.put(METER_SHAPE_PIE, new Byte(
1132:                            JRMeterPlot.SHAPE_PIE));
1133:                    meterShapeMap.put(new Byte(JRMeterPlot.SHAPE_CHORD),
1134:                            METER_SHAPE_CHORD);
1135:                    meterShapeMap.put(new Byte(JRMeterPlot.SHAPE_CIRCLE),
1136:                            METER_SHAPE_CIRCLE);
1137:                    meterShapeMap.put(new Byte(JRMeterPlot.SHAPE_PIE),
1138:                            METER_SHAPE_PIE);
1139:                }
1140:
1141:                return meterShapeMap;
1142:            }
1143:
1144:            /**
1145:             *
1146:             */
1147:            private static final String THERMOMETER_VALUE_LOCATION_NONE = "none";
1148:            private static final String THERMOMETER_VALUE_LOCATION_LEFT = "left";
1149:            private static final String THERMOMETER_VALUE_LOCATION_RIGHT = "right";
1150:            private static final String THERMOMETER_VALUE_LOCATION_BULB = "bulb";
1151:
1152:            private static Map thermometerValueLocationMap = null;
1153:
1154:            public static Map getThermometerValueLocationMap() {
1155:                if (thermometerValueLocationMap == null) {
1156:                    thermometerValueLocationMap = new HashMap();
1157:                    thermometerValueLocationMap.put(
1158:                            THERMOMETER_VALUE_LOCATION_NONE, new Byte(
1159:                                    JRThermometerPlot.LOCATION_NONE));
1160:                    thermometerValueLocationMap.put(
1161:                            THERMOMETER_VALUE_LOCATION_LEFT, new Byte(
1162:                                    JRThermometerPlot.LOCATION_LEFT));
1163:                    thermometerValueLocationMap.put(
1164:                            THERMOMETER_VALUE_LOCATION_RIGHT, new Byte(
1165:                                    JRThermometerPlot.LOCATION_RIGHT));
1166:                    thermometerValueLocationMap.put(
1167:                            THERMOMETER_VALUE_LOCATION_BULB, new Byte(
1168:                                    JRThermometerPlot.LOCATION_BULB));
1169:                    thermometerValueLocationMap.put(new Byte(
1170:                            JRThermometerPlot.LOCATION_NONE),
1171:                            THERMOMETER_VALUE_LOCATION_NONE);
1172:                    thermometerValueLocationMap.put(new Byte(
1173:                            JRThermometerPlot.LOCATION_LEFT),
1174:                            THERMOMETER_VALUE_LOCATION_LEFT);
1175:                    thermometerValueLocationMap.put(new Byte(
1176:                            JRThermometerPlot.LOCATION_RIGHT),
1177:                            THERMOMETER_VALUE_LOCATION_RIGHT);
1178:                    thermometerValueLocationMap.put(new Byte(
1179:                            JRThermometerPlot.LOCATION_BULB),
1180:                            THERMOMETER_VALUE_LOCATION_BULB);
1181:                }
1182:
1183:                return thermometerValueLocationMap;
1184:            }
1185:
1186:            /**
1187:             *
1188:             */
1189:            private static final String AXIS_POSITION_LEFT_OR_TOP = "leftOrTop";
1190:            private static final String AXIS_POSITION_RIGHT_OR_BOTTOM = "rightOrBottom";
1191:
1192:            private static Map axisPositionMap = null;
1193:
1194:            public static Map getAxisPositionMap() {
1195:                if (axisPositionMap == null) {
1196:                    axisPositionMap = new HashMap();
1197:                    axisPositionMap.put(AXIS_POSITION_LEFT_OR_TOP, new Byte(
1198:                            JRChartAxis.POSITION_LEFT_OR_TOP));
1199:                    axisPositionMap.put(AXIS_POSITION_RIGHT_OR_BOTTOM,
1200:                            new Byte(JRChartAxis.POSITION_RIGHT_OR_BOTTOM));
1201:                    axisPositionMap.put(new Byte(
1202:                            JRChartAxis.POSITION_LEFT_OR_TOP),
1203:                            AXIS_POSITION_LEFT_OR_TOP);
1204:                    axisPositionMap.put(new Byte(
1205:                            JRChartAxis.POSITION_RIGHT_OR_BOTTOM),
1206:                            AXIS_POSITION_RIGHT_OR_BOTTOM);
1207:                }
1208:
1209:                return axisPositionMap;
1210:            }
1211:
1212:            /**
1213:             *
1214:             */
1215:            private static final String CROSSTAB_BUCKET_ORDER_ASCENDING = "Ascending";
1216:            private static final String CROSSTAB_BUCKET_ORDER_DESCENDING = "Descending";
1217:
1218:            private static Map crosstabBucketOrderMap = null;
1219:
1220:            public static Map getCrosstabBucketOrderMap() {
1221:                if (crosstabBucketOrderMap == null) {
1222:                    crosstabBucketOrderMap = new HashMap();
1223:                    crosstabBucketOrderMap.put(CROSSTAB_BUCKET_ORDER_ASCENDING,
1224:                            new Byte(BucketDefinition.ORDER_ASCENDING));
1225:                    crosstabBucketOrderMap.put(
1226:                            CROSSTAB_BUCKET_ORDER_DESCENDING, new Byte(
1227:                                    BucketDefinition.ORDER_DESCENDING));
1228:                    crosstabBucketOrderMap.put(new Byte(
1229:                            BucketDefinition.ORDER_ASCENDING),
1230:                            CROSSTAB_BUCKET_ORDER_ASCENDING);
1231:                    crosstabBucketOrderMap.put(new Byte(
1232:                            BucketDefinition.ORDER_DESCENDING),
1233:                            CROSSTAB_BUCKET_ORDER_DESCENDING);
1234:                }
1235:
1236:                return crosstabBucketOrderMap;
1237:            }
1238:
1239:            private static final String CROSSTAB_PERCENTAGE_NONE = "None";
1240:            private static final String CROSSTAB_PERCENTAGE_GRAND_TOTAL = "GrandTotal";
1241:
1242:            private static Map crosstabPercentageMap = null;
1243:
1244:            public static Map getCrosstabPercentageMap() {
1245:                if (crosstabPercentageMap == null) {
1246:                    crosstabPercentageMap = new HashMap();
1247:                    crosstabPercentageMap.put(CROSSTAB_PERCENTAGE_NONE,
1248:                            new Byte(JRCrosstabMeasure.PERCENTAGE_TYPE_NONE));
1249:                    crosstabPercentageMap
1250:                            .put(
1251:                                    CROSSTAB_PERCENTAGE_GRAND_TOTAL,
1252:                                    new Byte(
1253:                                            JRCrosstabMeasure.PERCENTAGE_TYPE_GRAND_TOTAL));
1254:                    crosstabPercentageMap.put(new Byte(
1255:                            JRCrosstabMeasure.PERCENTAGE_TYPE_NONE),
1256:                            CROSSTAB_PERCENTAGE_NONE);
1257:                    crosstabPercentageMap.put(new Byte(
1258:                            JRCrosstabMeasure.PERCENTAGE_TYPE_GRAND_TOTAL),
1259:                            CROSSTAB_PERCENTAGE_GRAND_TOTAL);
1260:                }
1261:
1262:                return crosstabPercentageMap;
1263:            }
1264:
1265:            private static final String CROSSTAB_TOTAL_POSITION_NONE = "None";
1266:            private static final String CROSSTAB_TOTAL_POSITION_START = "Start";
1267:            private static final String CROSSTAB_TOTAL_POSITION_END = "End";
1268:
1269:            private static Map crosstabTotalPositionMap = null;
1270:
1271:            public static Map getCrosstabTotalPositionMap() {
1272:                if (crosstabTotalPositionMap == null) {
1273:                    crosstabTotalPositionMap = new HashMap();
1274:                    crosstabTotalPositionMap.put(CROSSTAB_TOTAL_POSITION_NONE,
1275:                            new Byte(BucketDefinition.TOTAL_POSITION_NONE));
1276:                    crosstabTotalPositionMap.put(CROSSTAB_TOTAL_POSITION_START,
1277:                            new Byte(BucketDefinition.TOTAL_POSITION_START));
1278:                    crosstabTotalPositionMap.put(CROSSTAB_TOTAL_POSITION_END,
1279:                            new Byte(BucketDefinition.TOTAL_POSITION_END));
1280:                    crosstabTotalPositionMap.put(new Byte(
1281:                            BucketDefinition.TOTAL_POSITION_NONE),
1282:                            CROSSTAB_TOTAL_POSITION_NONE);
1283:                    crosstabTotalPositionMap.put(new Byte(
1284:                            BucketDefinition.TOTAL_POSITION_START),
1285:                            CROSSTAB_TOTAL_POSITION_START);
1286:                    crosstabTotalPositionMap.put(new Byte(
1287:                            BucketDefinition.TOTAL_POSITION_END),
1288:                            CROSSTAB_TOTAL_POSITION_END);
1289:                }
1290:
1291:                return crosstabTotalPositionMap;
1292:            }
1293:
1294:            private static final String CROSSTAB_ROW_POSITION_TOP = "Top";
1295:            private static final String CROSSTAB_ROW_POSITION_MIDDLE = "Middle";
1296:            private static final String CROSSTAB_ROW_POSITION_BOTTOM = "Bottom";
1297:            private static final String CROSSTAB_ROW_POSITION_STRETCH = "Stretch";
1298:
1299:            private static Map crosstabRowPositionMap = null;
1300:
1301:            public static Map getCrosstabRowPositionMap() {
1302:                if (crosstabRowPositionMap == null) {
1303:                    crosstabRowPositionMap = new HashMap();
1304:                    crosstabRowPositionMap.put(CROSSTAB_ROW_POSITION_TOP,
1305:                            new Byte(JRCellContents.POSITION_Y_TOP));
1306:                    crosstabRowPositionMap.put(CROSSTAB_ROW_POSITION_MIDDLE,
1307:                            new Byte(JRCellContents.POSITION_Y_MIDDLE));
1308:                    crosstabRowPositionMap.put(CROSSTAB_ROW_POSITION_BOTTOM,
1309:                            new Byte(JRCellContents.POSITION_Y_BOTTOM));
1310:                    crosstabRowPositionMap.put(CROSSTAB_ROW_POSITION_STRETCH,
1311:                            new Byte(JRCellContents.POSITION_Y_STRETCH));
1312:                    crosstabRowPositionMap.put(new Byte(
1313:                            JRCellContents.POSITION_Y_TOP),
1314:                            CROSSTAB_ROW_POSITION_TOP);
1315:                    crosstabRowPositionMap.put(new Byte(
1316:                            JRCellContents.POSITION_Y_MIDDLE),
1317:                            CROSSTAB_ROW_POSITION_MIDDLE);
1318:                    crosstabRowPositionMap.put(new Byte(
1319:                            JRCellContents.POSITION_Y_BOTTOM),
1320:                            CROSSTAB_ROW_POSITION_BOTTOM);
1321:                    crosstabRowPositionMap.put(new Byte(
1322:                            JRCellContents.POSITION_Y_STRETCH),
1323:                            CROSSTAB_ROW_POSITION_STRETCH);
1324:                }
1325:
1326:                return crosstabRowPositionMap;
1327:            }
1328:
1329:            private static final String CROSSTAB_COLUMN_POSITION_LEFT = "Left";
1330:            private static final String CROSSTAB_COLUMN_POSITION_CENTER = "Center";
1331:            private static final String CROSSTAB_COLUMN_POSITION_RIGHT = "Right";
1332:            private static final String CROSSTAB_COLUMN_POSITION_STRETCH = "Stretch";
1333:
1334:            private static Map crosstabColumnPositionMap = null;
1335:
1336:            public static Map getCrosstabColumnPositionMap() {
1337:                if (crosstabColumnPositionMap == null) {
1338:                    crosstabColumnPositionMap = new HashMap();
1339:                    crosstabColumnPositionMap.put(
1340:                            CROSSTAB_COLUMN_POSITION_LEFT, new Byte(
1341:                                    JRCellContents.POSITION_X_LEFT));
1342:                    crosstabColumnPositionMap.put(
1343:                            CROSSTAB_COLUMN_POSITION_CENTER, new Byte(
1344:                                    JRCellContents.POSITION_X_CENTER));
1345:                    crosstabColumnPositionMap.put(
1346:                            CROSSTAB_COLUMN_POSITION_RIGHT, new Byte(
1347:                                    JRCellContents.POSITION_X_RIGHT));
1348:                    crosstabColumnPositionMap.put(
1349:                            CROSSTAB_COLUMN_POSITION_STRETCH, new Byte(
1350:                                    JRCellContents.POSITION_X_STRETCH));
1351:                    crosstabColumnPositionMap.put(new Byte(
1352:                            JRCellContents.POSITION_X_LEFT),
1353:                            CROSSTAB_COLUMN_POSITION_LEFT);
1354:                    crosstabColumnPositionMap.put(new Byte(
1355:                            JRCellContents.POSITION_X_CENTER),
1356:                            CROSSTAB_COLUMN_POSITION_CENTER);
1357:                    crosstabColumnPositionMap.put(new Byte(
1358:                            JRCellContents.POSITION_X_RIGHT),
1359:                            CROSSTAB_COLUMN_POSITION_RIGHT);
1360:                    crosstabColumnPositionMap.put(new Byte(
1361:                            JRCellContents.POSITION_X_STRETCH),
1362:                            CROSSTAB_COLUMN_POSITION_STRETCH);
1363:                }
1364:
1365:                return crosstabColumnPositionMap;
1366:            }
1367:
1368:            /**
1369:             *
1370:             */
1371:            public static Color getColor(String strColor, Color defaultColor) {
1372:                Color color = null;
1373:
1374:                if (strColor != null && strColor.length() > 0) {
1375:                    char firstChar = strColor.charAt(0);
1376:                    if (firstChar == '#') {
1377:                        color = new Color(Integer.parseInt(strColor
1378:                                .substring(1), 16));
1379:                    } else if ('0' <= firstChar && firstChar <= '9') {
1380:                        color = new Color(Integer.parseInt(strColor));
1381:                    } else {
1382:                        if (JRXmlConstants.getColorMap().containsKey(strColor)) {
1383:                            color = (Color) JRXmlConstants.getColorMap().get(
1384:                                    strColor);
1385:                        } else {
1386:                            color = defaultColor;
1387:                        }
1388:                    }
1389:                }
1390:
1391:                return color;
1392:            }
1393:
1394:            /**
1395:             *
1396:             */
1397:            public static final String JASPERREPORT_PUBLIC_ID = "-//JasperReports//DTD JasperReport//EN";
1398:            public static final String JASPERREPORT_SYSTEM_ID = "http://jasperreports.sourceforge.net/dtds/jasperreport.dtd";
1399:            public static final String JASPERREPORT_DTD = "net/sf/jasperreports/engine/dtds/jasperreport.dtd";
1400:            public static final String JASPERPRINT_PUBLIC_ID = "-//JasperReports//DTD JasperPrint//EN";
1401:            public static final String JASPERPRINT_SYSTEM_ID = "http://jasperreports.sourceforge.net/dtds/jasperprint.dtd";
1402:            public static final String JASPERPRINT_DTD = "net/sf/jasperreports/engine/dtds/jasperprint.dtd";
1403:
1404:            /**
1405:             * Template XML public ID.
1406:             */
1407:            public static final String JASPERTEMPLATE_PUBLIC_ID = "-//JasperReports//DTD Template//EN";
1408:
1409:            /**
1410:             * Template XML system ID.
1411:             */
1412:            public static final String JASPERTEMPLATE_SYSTEM_ID = "http://jasperreports.sourceforge.net/dtds/jaspertemplate.dtd";
1413:
1414:            /**
1415:             * DTD location for template XMLs.
1416:             */
1417:            public static final String JASPERTEMPLATE_DTD = "net/sf/jasperreports/engine/dtds/jaspertemplate.dtd";
1418:
1419:            /**
1420:             *	JasperDesignFactory associated constants
1421:             */
1422:            public static final String ELEMENT_jasperReport = "jasperReport";
1423:            public static final String ATTRIBUTE_name = "name";
1424:            public static final String ATTRIBUTE_language = "language";
1425:            public static final String ATTRIBUTE_columnCount = "columnCount";
1426:            public static final String ATTRIBUTE_printOrder = "printOrder";
1427:            public static final String ATTRIBUTE_pageWidth = "pageWidth";
1428:            public static final String ATTRIBUTE_pageHeight = "pageHeight";
1429:            public static final String ATTRIBUTE_orientation = "orientation";
1430:            public static final String ATTRIBUTE_whenNoDataType = "whenNoDataType";
1431:            public static final String ATTRIBUTE_columnWidth = "columnWidth";
1432:            public static final String ATTRIBUTE_columnSpacing = "columnSpacing";
1433:            public static final String ATTRIBUTE_leftMargin = "leftMargin";
1434:            public static final String ATTRIBUTE_rightMargin = "rightMargin";
1435:            public static final String ATTRIBUTE_topMargin = "topMargin";
1436:            public static final String ATTRIBUTE_bottomMargin = "bottomMargin";
1437:            public static final String ATTRIBUTE_isTitleNewPage = "isTitleNewPage";
1438:            public static final String ATTRIBUTE_isSummaryNewPage = "isSummaryNewPage";
1439:            public static final String ATTRIBUTE_isFloatColumnFooter = "isFloatColumnFooter";
1440:            public static final String ATTRIBUTE_scriptletClass = "scriptletClass";
1441:            public static final String ATTRIBUTE_formatFactoryClass = "formatFactoryClass";
1442:            public static final String ATTRIBUTE_resourceBundle = "resourceBundle";
1443:            public static final String ATTRIBUTE_whenResourceMissingType = "whenResourceMissingType";
1444:            public static final String ATTRIBUTE_isIgnorePagination = "isIgnorePagination";
1445:
1446:            public static final String ATTRIBUTE_value = "value";
1447:
1448:            public static final String ELEMENT_import = "import";
1449:            public static final String ELEMENT_background = "background";
1450:            public static final String ELEMENT_title = "title";
1451:            public static final String ELEMENT_pageHeader = "pageHeader";
1452:            public static final String ELEMENT_columnHeader = "columnHeader";
1453:            public static final String ELEMENT_detail = "detail";
1454:            public static final String ELEMENT_columnFooter = "columnFooter";
1455:            public static final String ELEMENT_pageFooter = "pageFooter";
1456:            public static final String ELEMENT_lastPageFooter = "lastPageFooter";
1457:            public static final String ELEMENT_summary = "summary";
1458:            public static final String ELEMENT_noData = "noData";
1459:            public static final String ELEMENT_property = "property";
1460:
1461:            public static final String ELEMENT_page = "page";
1462:
1463:            /**
1464:             * JasperPrintFactory associated constants
1465:             */
1466:            public static final String ELEMENT_jasperPrint = "jasperPrint";
1467:            public static final String ATTRIBUTE_locale = "locale";
1468:            public static final String ATTRIBUTE_timezone = "timezone";
1469:
1470:            /**
1471:             * JRBandFactory associated constants
1472:             */
1473:            public static final String ELEMENT_band = "band";
1474:            public static final String ELEMENT_printWhenExpression = "printWhenExpression";
1475:
1476:            public static final String ATTRIBUTE_height = "height";
1477:            public static final String ATTRIBUTE_isSplitAllowed = "isSplitAllowed";
1478:
1479:            /**
1480:             * JRBoxFactory associated constants
1481:             */
1482:            public static final String ELEMENT_box = "box";
1483:
1484:            public static final String ATTRIBUTE_border = "border";
1485:            public static final String ATTRIBUTE_borderColor = "borderColor";
1486:            public static final String ATTRIBUTE_padding = "padding";
1487:            public static final String ATTRIBUTE_topBorder = "topBorder";
1488:            public static final String ATTRIBUTE_topBorderColor = "topBorderColor";
1489:            public static final String ATTRIBUTE_topPadding = "topPadding";
1490:            public static final String ATTRIBUTE_leftBorder = "leftBorder";
1491:            public static final String ATTRIBUTE_leftBorderColor = "leftBorderColor";
1492:            public static final String ATTRIBUTE_leftPadding = "leftPadding";
1493:            public static final String ATTRIBUTE_bottomBorder = "bottomBorder";
1494:            public static final String ATTRIBUTE_bottomBorderColor = "bottomBorderColor";
1495:            public static final String ATTRIBUTE_bottomPadding = "bottomPadding";
1496:            public static final String ATTRIBUTE_rightBorder = "rightBorder";
1497:            public static final String ATTRIBUTE_rightBorderColor = "rightBorderColor";
1498:            public static final String ATTRIBUTE_rightPadding = "rightPadding";
1499:
1500:            /**
1501:             * JRBreakFactory associated constants
1502:             */
1503:            public static final String ELEMENT_break = "break";
1504:
1505:            public static final String ATTRIBUTE_type = "type";
1506:
1507:            /**
1508:             * JRChartFactory associated constants
1509:             */
1510:            public static final String ELEMENT_chart = "chart";
1511:            public static final String ELEMENT_chartTitle = "chartTitle";
1512:            public static final String ELEMENT_titleExpression = "titleExpression";
1513:            public static final String ELEMENT_chartSubtitle = "chartSubtitle";
1514:            public static final String ELEMENT_subtitleExpression = "subtitleExpression";
1515:            public static final String ELEMENT_chartLegend = "chartLegend";
1516:
1517:            public static final String ELEMENT_pieChart = "pieChart";
1518:            public static final String ELEMENT_pie3DChart = "pie3DChart";
1519:            public static final String ELEMENT_barChart = "barChart";
1520:            public static final String ELEMENT_bar3DChart = "bar3DChart";
1521:            public static final String ELEMENT_bubbleChart = "bubbleChart";
1522:            public static final String ELEMENT_stackedBarChart = "stackedBarChart";
1523:            public static final String ELEMENT_stackedBar3DChart = "stackedBar3DChart";
1524:            public static final String ELEMENT_lineChart = "lineChart";
1525:            public static final String ELEMENT_highLowChart = "highLowChart";
1526:            public static final String ELEMENT_candlestickChart = "candlestickChart";
1527:            public static final String ELEMENT_areaChart = "areaChart";
1528:            public static final String ELEMENT_scatterChart = "scatterChart";
1529:            public static final String ELEMENT_timeSeriesChart = "timeSeriesChart";
1530:            public static final String ELEMENT_xyAreaChart = "xyAreaChart";
1531:            public static final String ELEMENT_xyBarChart = "xyBarChart";
1532:            public static final String ELEMENT_xyLineChart = "xyLineChart";
1533:            public static final String ELEMENT_meterChart = "meterChart";
1534:            public static final String ELEMENT_thermometerChart = "thermometerChart";
1535:            public static final String ELEMENT_multiAxisChart = "multiAxisChart";
1536:            public static final String ELEMENT_stackedAreaChart = "stackedAreaChart";
1537:
1538:            public static final String ATTRIBUTE_isShowLegend = "isShowLegend";
1539:            public static final String ATTRIBUTE_evaluationTime = "evaluationTime";
1540:            public static final String ATTRIBUTE_evaluationGroup = "evaluationGroup";
1541:            public static final String ATTRIBUTE_bookmarkLevel = "bookmarkLevel";
1542:            public static final String ATTRIBUTE_customizerClass = "customizerClass";
1543:
1544:            /**
1545:             * JRChartAxisFormatFactory associated constants
1546:             */
1547:            public static final String ELEMENT_axisFormat = "axisFormat";
1548:            public static final String ELEMENT_labelFont = "labelFont";
1549:            public static final String ELEMENT_tickLabelFont = "tickLabelFont";
1550:            public static final String ATTRIBUTE_labelColor = "labelColor";
1551:            public static final String ATTRIBUTE_tickLabelColor = "tickLabelColor";
1552:            public static final String ATTRIBUTE_tickLabelMask = "tickLabelMask";
1553:            public static final String ATTRIBUTE_axisLineColor = "axisLineColor";
1554:
1555:            /**
1556:             * JRChartLegendFactory associated constants
1557:             */
1558:            public static final String ATTRIBUTE_textColor = "textColor";
1559:            public static final String ATTRIBUTE_backgroundColor = "backgroundColor";
1560:
1561:            /**
1562:             * JRChartTitleFactory associated constants
1563:             */
1564:            public static final String ATTRIBUTE_position = "position";
1565:            public static final String ATTRIBUTE_color = "color";
1566:
1567:            /**
1568:             * JRChartPlotFactory associated constants
1569:             */
1570:            public static final String ELEMENT_plot = "plot";
1571:            public static final String ELEMENT_piePlot = "piePlot";
1572:            public static final String ELEMENT_pie3DPlot = "pie3DPlot";
1573:            public static final String ELEMENT_barPlot = "barPlot";
1574:            public static final String ELEMENT_bubblePlot = "bubblePlot";
1575:            public static final String ELEMENT_linePlot = "linePlot";
1576:            public static final String ELEMENT_timeSeriesPlot = "timeSeriesPlot";
1577:            public static final String ELEMENT_bar3DPlot = "bar3DPlot";
1578:            public static final String ELEMENT_highLowPlot = "highLowPlot";
1579:            public static final String ELEMENT_candlestickPlot = "candlestickPlot";
1580:            public static final String ELEMENT_areaPlot = "areaPlot";
1581:            public static final String ELEMENT_scatterPlot = "scatterPlot";
1582:            public static final String ELEMENT_multiAxisPlot = "multiAxisPlot";
1583:
1584:            public static final String ELEMENT_valueDisplay = "valueDisplay";
1585:            public static final String ELEMENT_dataRange = "dataRange";
1586:            public static final String ELEMENT_meterInterval = "meterInterval";
1587:            public static final String ELEMENT_categoryAxisFormat = "categoryAxisFormat";
1588:            public static final String ELEMENT_valueAxisFormat = "valueAxisFormat";
1589:            public static final String ELEMENT_xAxisFormat = "xAxisFormat";
1590:            public static final String ELEMENT_yAxisFormat = "yAxisFormat";
1591:            public static final String ELEMENT_timeAxisFormat = "timeAxisFormat";
1592:
1593:            public static final String ELEMENT_lowExpression = "lowExpression";
1594:            public static final String ELEMENT_highExpression = "highExpression";
1595:            public static final String ELEMENT_categoryAxisLabelExpression = "categoryAxisLabelExpression";
1596:            public static final String ELEMENT_valueAxisLabelExpression = "valueAxisLabelExpression";
1597:            public static final String ELEMENT_xAxisLabelExpression = "xAxisLabelExpression";
1598:            public static final String ELEMENT_yAxisLabelExpression = "yAxisLabelExpression";
1599:            public static final String ELEMENT_timeAxisLabelExpression = "timeAxisLabelExpression";
1600:
1601:            public static final String ATTRIBUTE_backgroundAlpha = "backgroundAlpha";
1602:            public static final String ATTRIBUTE_foregroundAlpha = "foregroundAlpha";
1603:            public static final String ATTRIBUTE_labelRotation = "labelRotation";
1604:
1605:            public static final String ATTRIBUTE_mask = "mask";
1606:            public static final String ATTRIBUTE_label = "label";
1607:            public static final String ATTRIBUTE_alpha = "alpha";
1608:            public static final String ATTRIBUTE_depthFactor = "depthFactor";
1609:            public static final String ATTRIBUTE_isShowLabels = "isShowLabels";
1610:            public static final String ATTRIBUTE_isShowTickLabels = "isShowTickLabels";
1611:            public static final String ATTRIBUTE_scaleType = "scaleType";
1612:            public static final String ATTRIBUTE_isShowTickMarks = "isShowTickMarks";
1613:            public static final String ATTRIBUTE_isShowLines = "isShowLines";
1614:            public static final String ATTRIBUTE_isShowShapes = "isShowShapes";
1615:            public static final String ATTRIBUTE_xOffset = "xOffset";
1616:            public static final String ATTRIBUTE_yOffset = "yOffset";
1617:            public static final String ATTRIBUTE_isShowOpenTicks = "isShowOpenTicks";
1618:            public static final String ATTRIBUTE_isShowCloseTicks = "isShowCloseTicks";
1619:            public static final String ATTRIBUTE_isShowVolume = "isShowVolume";
1620:            public static final String ATTRIBUTE_isCircular = "isCircular";
1621:
1622:            /**
1623:             * JRSeriesColorFactory associated constants
1624:             */
1625:            public static final String ELEMENT_seriesColor = "seriesColor";
1626:
1627:            public static final String ATTRIBUTE_seriesOrder = "seriesOrder";
1628:
1629:            /**
1630:             * JRConditionalStyleFactory associated constants
1631:             */
1632:            public static final String ELEMENT_conditionalStyle = "conditionalStyle";
1633:            public static final String ELEMENT_conditionExpression = "conditionExpression";
1634:
1635:            /**
1636:             * JRStyleFactory associated constants
1637:             */
1638:            public static final String ELEMENT_style = "style";
1639:
1640:            public static final String ATTRIBUTE_isDefault = "isDefault";
1641:            public static final String ATTRIBUTE_mode = "mode";
1642:            public static final String ATTRIBUTE_forecolor = "forecolor";
1643:            public static final String ATTRIBUTE_backcolor = "backcolor";
1644:            public static final String ATTRIBUTE_style = "style";
1645:
1646:            public static final String ATTRIBUTE_radius = "radius";
1647:
1648:            // these are inherited by both images and texts.
1649:
1650:            public static final String ATTRIBUTE_rotation = "rotation";
1651:            public static final String ATTRIBUTE_lineSpacing = "lineSpacing";
1652:            public static final String ATTRIBUTE_isStyledText = "isStyledText";
1653:            public static final String ATTRIBUTE_pattern = "pattern";
1654:            public static final String ATTRIBUTE_isBlankWhenNull = "isBlankWhenNull";
1655:
1656:            public static final String ATTRIBUTE_fontSize = "fontSize";
1657:
1658:            /**
1659:             * JRDatasetFactory associated constants
1660:             */
1661:            public static final String ELEMENT_subDataset = "subDataset";
1662:            public static final String ELEMENT_filterExpression = "filterExpression";
1663:
1664:            /**
1665:             * JRDatasetRunFactory associated constants
1666:             */
1667:            public static final String ELEMENT_datasetRun = "datasetRun";
1668:
1669:            public static final String ELEMENT_parametersMapExpression = "parametersMapExpression";
1670:            public static final String ELEMENT_connectionExpression = "connectionExpression";
1671:            public static final String ELEMENT_dataSourceExpression = "dataSourceExpression";
1672:
1673:            public static final String ATTRIBUTE_subDataset = "subDataset";
1674:
1675:            /**
1676:             * JRDatasetRunParameterExpressionFactory associated constants
1677:             */
1678:            public static final String ELEMENT_datasetParameterExpression = "datasetParameterExpression";
1679:
1680:            /**
1681:             * JRDatasetRunParameterFactory associated constants
1682:             */
1683:            public static final String ELEMENT_datasetParameter = "datasetParameter";
1684:
1685:            /**
1686:             * JRElementDatasetFactory associated constants
1687:             */
1688:            public static final String ELEMENT_dataset = "dataset";
1689:            public static final String ELEMENT_categoryDataset = "categoryDataset";
1690:            public static final String ELEMENT_timeSeriesDataset = "timeSeriesDataset";
1691:            public static final String ELEMENT_timePeriodDataset = "timePeriodDataset";
1692:            public static final String ELEMENT_xyzDataset = "xyzDataset";
1693:            public static final String ELEMENT_xyDataset = "xyDataset";
1694:            public static final String ELEMENT_pieDataset = "pieDataset";
1695:            public static final String ELEMENT_valueDataset = "pieDataset";
1696:            public static final String ELEMENT_highLowDataset = "highLowDataset";
1697:
1698:            public static final String ELEMENT_categorySeries = "categorySeries";
1699:            public static final String ELEMENT_xyzSeries = "xyzSeries";
1700:            public static final String ELEMENT_xySeries = "xySeries";
1701:            public static final String ELEMENT_timeSeries = "timeSeries";
1702:            public static final String ELEMENT_timePeriodSeries = "timePeriodSeries";
1703:
1704:            public static final String ELEMENT_incrementWhenExpression = "incrementWhenExpression";
1705:            public static final String ELEMENT_keyExpression = "keyExpression";
1706:            public static final String ELEMENT_valueExpression = "valueExpression";
1707:            public static final String ELEMENT_labelExpression = "labelExpression";
1708:            public static final String ELEMENT_seriesExpression = "seriesExpression";
1709:            public static final String ELEMENT_categoryExpression = "categoryExpression";
1710:            public static final String ELEMENT_xValueExpression = "xValueExpression";
1711:            public static final String ELEMENT_yValueExpression = "yValueExpression";
1712:            public static final String ELEMENT_zValueExpression = "zValueExpression";
1713:            public static final String ELEMENT_timePeriodExpression = "timePeriodExpression";
1714:            public static final String ELEMENT_startDateExpression = "startDateExpression";
1715:            public static final String ELEMENT_endDateExpression = "endDateExpression";
1716:            public static final String ELEMENT_dateExpression = "dateExpression";
1717:            public static final String ELEMENT_openExpression = "openExpression";
1718:            public static final String ELEMENT_closeExpression = "closeExpression";
1719:            public static final String ELEMENT_volumeExpression = "volumeExpression";
1720:
1721:            public static final String ATTRIBUTE_timePeriod = "timePeriod";
1722:
1723:            /**
1724:             * JRElementFactory associated constants
1725:             */
1726:            public static final String ELEMENT_reportElement = "reportElement";
1727:
1728:            public static final String ATTRIBUTE_key = "key";
1729:            public static final String ATTRIBUTE_positionType = "positionType";
1730:            public static final String ATTRIBUTE_stretchType = "stretchType";
1731:            public static final String ATTRIBUTE_isPrintRepeatedValues = "isPrintRepeatedValues";
1732:            public static final String ATTRIBUTE_x = "x";
1733:            public static final String ATTRIBUTE_y = "y";
1734:            public static final String ATTRIBUTE_width = "width";
1735:            public static final String ATTRIBUTE_isRemoveLineWhenBlank = "isRemoveLineWhenBlank";
1736:            public static final String ATTRIBUTE_isPrintInFirstWholeBand = "isPrintInFirstWholeBand";
1737:            public static final String ATTRIBUTE_isPrintWhenDetailOverflows = "isPrintWhenDetailOverflows";
1738:            public static final String ATTRIBUTE_printWhenGroupChanges = "printWhenGroupChanges";
1739:
1740:            /**
1741:             * JRElementGroupFactory associated constants
1742:             */
1743:            public static final String ELEMENT_elementGroup = "elementGroup";
1744:
1745:            /**
1746:             * JREllipseFactory associated constants
1747:             */
1748:            public static final String ELEMENT_ellipse = "ellipse";
1749:
1750:            /**
1751:             * JRFieldFactory associated constants
1752:             */
1753:            public static final String ELEMENT_field = "field";
1754:            public static final String ELEMENT_fieldDescription = "fieldDescription";
1755:
1756:            public static final String ATTRIBUTE_class = "class";
1757:
1758:            /**
1759:             * JRFieldFactory associated constants
1760:             */
1761:            public static final String ELEMENT_font = "font";
1762:
1763:            public static final String ATTRIBUTE_reportFont = "reportFont";
1764:            public static final String ATTRIBUTE_fontName = "fontName";
1765:            public static final String ATTRIBUTE_isBold = "isBold";
1766:            public static final String ATTRIBUTE_isItalic = "isItalic";
1767:            public static final String ATTRIBUTE_isUnderline = "isUnderline";
1768:            public static final String ATTRIBUTE_isStrikeThrough = "isStrikeThrough";
1769:            public static final String ATTRIBUTE_size = "size";
1770:            public static final String ATTRIBUTE_pdfFontName = "pdfFontName";
1771:            public static final String ATTRIBUTE_pdfEncoding = "pdfEncoding";
1772:            public static final String ATTRIBUTE_isPdfEmbedded = "isPdfEmbedded";
1773:
1774:            /**
1775:             * JRFrameFactory associated constants
1776:             */
1777:            public static final String ELEMENT_frame = "frame";
1778:
1779:            /**
1780:             * JRGraphicElementFactory associated constants
1781:             */
1782:            public static final String ELEMENT_graphicElement = "graphicElement";
1783:
1784:            public static final String ATTRIBUTE_pen = "pen";
1785:            public static final String ATTRIBUTE_fill = "fill";
1786:
1787:            /**
1788:             * JRGroupFactory associated constants
1789:             */
1790:            public static final String ELEMENT_group = "group";
1791:            public static final String ELEMENT_groupExpression = "groupExpression";
1792:            public static final String ELEMENT_groupHeader = "groupHeader";
1793:            public static final String ELEMENT_groupFooter = "groupFooter";
1794:
1795:            public static final String ATTRIBUTE_isStartNewColumn = "isStartNewColumn";
1796:            public static final String ATTRIBUTE_isStartNewPage = "isStartNewPage";
1797:            public static final String ATTRIBUTE_isResetPageNumber = "isResetPageNumber";
1798:            public static final String ATTRIBUTE_isReprintHeaderOnEachPage = "isReprintHeaderOnEachPage";
1799:            public static final String ATTRIBUTE_minHeightToStartNewPage = "minHeightToStartNewPage";
1800:
1801:            /**
1802:             * JRHyperlinkFactory associated constants
1803:             */
1804:            public static final String ELEMENT_hyperlinkTooltipExpression = "hyperlinkTooltipExpression";
1805:            public static final String ELEMENT_sectionHyperlink = "sectionHyperlink";
1806:            public static final String ELEMENT_itemHyperlink = "itemHyperlink";
1807:            public static final String ELEMENT_anchorNameExpression = "anchorNameExpression";
1808:            public static final String ELEMENT_hyperlinkReferenceExpression = "hyperlinkReferenceExpression";
1809:            public static final String ELEMENT_hyperlinkAnchorExpression = "hyperlinkAnchorExpression";
1810:            public static final String ELEMENT_hyperlinkPageExpression = "hyperlinkPageExpression";
1811:
1812:            public static final String ATTRIBUTE_hyperlinkType = "hyperlinkType";
1813:            public static final String ATTRIBUTE_hyperlinkTarget = "hyperlinkTarget";
1814:
1815:            /**
1816:             * JRHyperlinkFactory associated constants
1817:             */
1818:            public static final String ELEMENT_hyperlinkParameterExpression = "hyperlinkParameterExpression";
1819:
1820:            /**
1821:             * JRHyperlinkParameterFactory associated constants
1822:             */
1823:            public static final String ELEMENT_hyperlinkParameter = "hyperlinkParameter";
1824:
1825:            /**
1826:             * JRImageFactory associated constants
1827:             */
1828:            public static final String ELEMENT_image = "image";
1829:            public static final String ELEMENT_imageSource = "imageSource";
1830:            public static final String ELEMENT_imageExpression = "imageExpression";
1831:
1832:            public static final String ATTRIBUTE_scaleImage = "scaleImage";
1833:            public static final String ATTRIBUTE_hAlign = "hAlign";
1834:            public static final String ATTRIBUTE_vAlign = "vAlign";
1835:            public static final String ATTRIBUTE_isUsingCache = "isUsingCache";
1836:            public static final String ATTRIBUTE_isLazy = "isLazy";
1837:            public static final String ATTRIBUTE_onErrorType = "onErrorType";
1838:
1839:            /**
1840:             * JRLineFactory associated constants
1841:             */
1842:            public static final String ELEMENT_line = "line";
1843:
1844:            public static final String ATTRIBUTE_direction = "direction";
1845:
1846:            /**
1847:             * JRParameterFactory associated constants
1848:             */
1849:            public static final String ELEMENT_parameter = "parameter";
1850:            public static final String ELEMENT_parameterDescription = "parameterDescription";
1851:            public static final String ELEMENT_defaultValueExpression = "defaultValueExpression";
1852:
1853:            public static final String ATTRIBUTE_isForPrompting = "isForPrompting";
1854:
1855:            /**
1856:             * JRPrintHyperlinkParameterValueFactory associated constants
1857:             */
1858:            public static final String ELEMENT_hyperlinkParameterValue = "hyperlinkParameterValue";
1859:
1860:            /**
1861:             * JRPrintImageFactory associated constants
1862:             */
1863:            public static final String ATTRIBUTE_anchorName = "anchorName";
1864:            public static final String ATTRIBUTE_hyperlinkReference = "hyperlinkReference";
1865:            public static final String ATTRIBUTE_hyperlinkAnchor = "hyperlinkAnchor";
1866:            public static final String ATTRIBUTE_hyperlinkPage = "hyperlinkPage";
1867:            public static final String ATTRIBUTE_hyperlinkTooltip = "hyperlinkTooltip";
1868:
1869:            /**
1870:             * JRPrintImageSourceFactory associated constants
1871:             */
1872:            public static final String ATTRIBUTE_isEmbedded = "isEmbedded";
1873:
1874:            /**
1875:             * JRPrintTextFactory associated constants
1876:             */
1877:            public static final String ATTRIBUTE_textAlignment = "textAlignment";
1878:            public static final String ATTRIBUTE_verticalAlignment = "verticalAlignment";
1879:            public static final String ATTRIBUTE_runDirection = "runDirection";
1880:            public static final String ATTRIBUTE_textHeight = "textHeight";
1881:            public static final String ATTRIBUTE_lineSpacingFactor = "lineSpacingFactor";
1882:            public static final String ATTRIBUTE_leadingOffset = "leadingOffset";
1883:            public static final String ATTRIBUTE_valueClass = "valueClass";
1884:
1885:            /**
1886:             * JRQueryFactory associated constants
1887:             */
1888:            public static final String ELEMENT_queryString = "queryString";
1889:
1890:            /**
1891:             * JRRectangleFactory associated constants
1892:             */
1893:            public static final String ELEMENT_rectangle = "rectangle";
1894:
1895:            /**
1896:             * JRSortFieldFactory associated constants
1897:             */
1898:            public static final String ELEMENT_sortField = "sortField";
1899:
1900:            public static final String ATTRIBUTE_order = "order";
1901:
1902:            /**
1903:             * JRStaticTextFactory associated constants
1904:             */
1905:            public static final String ELEMENT_staticText = "staticText";
1906:            public static final String ELEMENT_text = "text";
1907:            public static final String ELEMENT_textContent = "textContent";
1908:
1909:            /**
1910:             * JRSubreportExpressionFactory associated constants
1911:             */
1912:            public static final String ELEMENT_subreportExpression = "subreportExpression";
1913:
1914:            /**
1915:             * JRSubreportFactory associated constants
1916:             */
1917:            public static final String ELEMENT_subreport = "subreport";
1918:
1919:            /**
1920:             * JRSubreportParameterFactory associated constants
1921:             */
1922:            public static final String ELEMENT_subreportParameter = "subreportParameter";
1923:            public static final String ELEMENT_subreportParameterExpression = "subreportParameterExpression";
1924:
1925:            /**
1926:             * JRSubreportReturnValueFactory associated constants
1927:             */
1928:            public static final String ELEMENT_returnValue = "returnValue";
1929:
1930:            public static final String ATTRIBUTE_subreportVariable = "subreportVariable";
1931:            public static final String ATTRIBUTE_toVariable = "toVariable";
1932:
1933:            /**
1934:             * JRTextElementFactory associated constants
1935:             */
1936:            public static final String ELEMENT_textElement = "textElement";
1937:
1938:            /**
1939:             * JRTextFieldExpressionFactory associated constants
1940:             */
1941:            public static final String ELEMENT_textFieldExpression = "textFieldExpression";
1942:
1943:            /**
1944:             * JRTextFieldFactory  associated constants
1945:             */
1946:            public static final String ELEMENT_textField = "textField";
1947:
1948:            public static final String ATTRIBUTE_isStretchWithOverflow = "isStretchWithOverflow";
1949:
1950:            /**
1951:             * JRVariableFactory  associated constants
1952:             */
1953:            public static final String ELEMENT_variable = "variable";
1954:            public static final String ELEMENT_variableExpression = "variableExpression";
1955:            public static final String ELEMENT_initialValueExpression = "initialValueExpression";
1956:
1957:            public static final String ATTRIBUTE_resetType = "resetType";
1958:            public static final String ATTRIBUTE_resetGroup = "resetGroup";
1959:            public static final String ATTRIBUTE_incrementType = "incrementType";
1960:            public static final String ATTRIBUTE_incrementGroup = "incrementGroup";
1961:            public static final String ATTRIBUTE_calculation = "calculation";
1962:            public static final String ATTRIBUTE_incrementerFactoryClass = "incrementerFactoryClass";
1963:
1964:            /**
1965:             * JRReportFontFactory  associated constants
1966:             */
1967:            public static final String ELEMENT_reportFont = "reportFont";
1968:
1969:            public static final String ELEMENT_template = "template";
1970:
1971:            public static final String TEMPLATE_ELEMENT_ROOT = "jasperTemplate";
1972:            public static final String TEMPLATE_ELEMENT_INCLUDED_TEMPLATE = "template";
1973:
1974:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.